Brave Vpn api integration (#9131)

* Add vpn api integration to components

* Add api implementation for guardian

* Update name conventions

Update deps

* Add misssing includes

* Fix include_rule error

* Fix lint error

* Update vpn deps

* Refactor vpn files

Address comments on conversation

* Add check for record_v

* Address PR comments

* Fix gn_check error

* Address PR comments

* Add check for android to avoid error on other platforms

android/brave_java_sources.gni

@@ -218,6 +218,8 @@ brave_java_sources = [
   "../../brave/android/java/org/chromium/chrome/browser/util/ImageUtils.java",
   "../../brave/android/java/org/chromium/chrome/browser/util/PackageUtils.java",
   "../../brave/android/java/org/chromium/chrome/browser/util/TabUtils.java",
+  "../../brave/android/java/org/chromium/chrome/browser/vpn/BraveVpnNativeWorker.java",
+  "../../brave/android/java/org/chromium/chrome/browser/vpn/BraveVpnObserver.java",
   "../../brave/android/java/org/chromium/chrome/browser/widget/crypto/binance/BinanceAccountBalance.java",
   "../../brave/android/java/org/chromium/chrome/browser/widget/crypto/binance/BinanceActivity.java",
   "../../brave/android/java/org/chromium/chrome/browser/widget/crypto/binance/BinanceBuyFragment.java",

android/java/org/chromium/chrome/browser/app/BraveActivity.java

@@ -101,6 +101,7 @@
 import org.chromium.chrome.browser.util.BraveDbUtil;
 import org.chromium.chrome.browser.util.BraveReferrer;
 import org.chromium.chrome.browser.util.PackageUtils;
+import org.chromium.chrome.browser.vpn.BraveVpnNativeWorker;
 import org.chromium.chrome.browser.widget.crypto.binance.BinanceAccountBalance;
 import org.chromium.chrome.browser.widget.crypto.binance.BinanceWidgetManager;
 import org.chromium.components.bookmarks.BookmarkId;
@@ -418,6 +419,7 @@ public void finishNativeInitialization() {
         }
         checkSetDefaultBrowserModal();
         checkFingerPrintingOnUpgrade();
+        BraveVpnNativeWorker.getInstance().getAllServerRegions();
     }
 
     private void checkFingerPrintingOnUpgrade() {

android/java/org/chromium/chrome/browser/vpn/BraveVpnNativeWorker.java

@@ -0,0 +1,142 @@
+/**
+ * Copyright (c) 2021 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+package org.chromium.chrome.browser.vpn;
+
+import org.chromium.base.annotations.CalledByNative;
+import org.chromium.base.annotations.JNINamespace;
+import org.chromium.chrome.browser.vpn.BraveVpnObserver;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@JNINamespace("chrome::android")
+public class BraveVpnNativeWorker {
+    private long mNativeBraveVpnNativeWorker;
+    private static final Object lock = new Object();
+    private static BraveVpnNativeWorker instance;
+
+    private List<BraveVpnObserver> mObservers;
+
+    public static BraveVpnNativeWorker getInstance() {
+        synchronized (lock) {
+            if (instance == null) {
+                instance = new BraveVpnNativeWorker();
+                instance.init();
+            }
+        }
+        return instance;
+    }
+
+    private BraveVpnNativeWorker() {
+        mObservers = new ArrayList<BraveVpnObserver>();
+    }
+
+    private void init() {
+        if (mNativeBraveVpnNativeWorker == 0) {
+            nativeInit();
+        }
+    }
+
+    @Override
+    protected void finalize() {
+        destroy();
+    }
+
+    private void destroy() {
+        if (mNativeBraveVpnNativeWorker != 0) {
+            nativeDestroy(mNativeBraveVpnNativeWorker);
+            mNativeBraveVpnNativeWorker = 0;
+        }
+    }
+
+    public void addObserver(BraveVpnObserver observer) {
+        synchronized (lock) {
+            mObservers.add(observer);
+        }
+    }
+
+    public void removeObserver(BraveVpnObserver observer) {
+        synchronized (lock) {
+            mObservers.remove(observer);
+        }
+    }
+
+    @CalledByNative
+    private void setNativePtr(long nativePtr) {
+        assert mNativeBraveVpnNativeWorker == 0;
+        mNativeBraveVpnNativeWorker = nativePtr;
+    }
+
+    @CalledByNative
+    public void onGetAllServerRegions(String jsonServerRegions, boolean isSuccess) {
+        for (BraveVpnObserver observer : mObservers) {
+            observer.onGetAllServerRegions(jsonServerRegions, isSuccess);
+        }
+    }
+
+    @CalledByNative
+    public void onGetTimezonesForRegions(String jsonTimezones, boolean isSuccess) {
+        for (BraveVpnObserver observer : mObservers) {
+            observer.onGetTimezonesForRegions(jsonTimezones, isSuccess);
+        }
+    }
+
+    @CalledByNative
+    public void onGetHostnamesForRegion(String jsonHostnames, boolean isSuccess) {
+        for (BraveVpnObserver observer : mObservers) {
+            observer.onGetHostnamesForRegion(jsonHostnames, isSuccess);
+        }
+    }
+
+    @CalledByNative
+    public void onGetSubscriberCredential(String subscriberCredential, boolean isSuccess) {
+        for (BraveVpnObserver observer : mObservers) {
+            observer.onGetSubscriberCredential(subscriberCredential, isSuccess);
+        }
+    }
+
+    @CalledByNative
+    public void onVerifyPurchaseToken(String jsonResponse, boolean isSuccess) {
+        for (BraveVpnObserver observer : mObservers) {
+            observer.onVerifyPurchaseToken(jsonResponse, isSuccess);
+        }
+    }
+
+    public void getAllServerRegions() {
+        nativeGetAllServerRegions(mNativeBraveVpnNativeWorker);
+    }
+
+    public void getTimezonesForRegions() {
+        nativeGetTimezonesForRegions(mNativeBraveVpnNativeWorker);
+    }
+
+    public void getHostnamesForRegion(String region) {
+        nativeGetHostnamesForRegion(mNativeBraveVpnNativeWorker, region);
+    }
+
+    public void getSubscriberCredential(
+            String productType, String productId, String validationMethod, String purchaseToken) {
+        nativeGetSubscriberCredential(mNativeBraveVpnNativeWorker, productType, productId,
+                validationMethod, purchaseToken);
+    }
+
+    public void verifyPurchaseToken(String purchaseToken, String productId, String productType) {
+        nativeVerifyPurchaseToken(
+                mNativeBraveVpnNativeWorker, purchaseToken, productId, productType);
+    }
+
+    private native void nativeInit();
+    private native void nativeDestroy(long nativeBraveVpnNativeWorker);
+    private native void nativeGetAllServerRegions(long nativeBraveVpnNativeWorker);
+    private native void nativeGetTimezonesForRegions(long nativeBraveVpnNativeWorker);
+    private native void nativeGetHostnamesForRegion(long nativeBraveVpnNativeWorker, String region);
+    private native void nativeGetSubscriberCredential(long nativeBraveVpnNativeWorker,
+            String productType, String productId, String validationMethod, String purchaseToken);
+    private native void nativeVerifyPurchaseToken(long nativeBraveVpnNativeWorker,
+            String purchaseToken, String productId, String productType);
+}

android/java/org/chromium/chrome/browser/vpn/BraveVpnObserver.java

@@ -0,0 +1,13 @@
+/* Copyright (c) 2021 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+package org.chromium.chrome.browser.vpn;
+
+public interface BraveVpnObserver {
+    default public void onGetAllServerRegions(String jsonServerRegions, boolean isSuccess){};
+    default public void onGetTimezonesForRegions(String jsonTimezones, boolean isSuccess){};
+    default public void onGetHostnamesForRegion(String jsonHostnames, boolean isSuccess){};
+    default public void onGetSubscriberCredential(String subscriberCredential, boolean isSuccess){};
+    default public void onVerifyPurchaseToken(String jsonResponse, boolean isSuccess){};
+}

browser/brave_vpn/android/brave_vpn_native_worker.cc

@@ -0,0 +1,173 @@
+/* Copyright (c) 2021 The Brave Authors. All rights reserved.
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "brave/browser/brave_vpn/android/brave_vpn_native_worker.h"
+
+#include "base/android/jni_android.h"
+#include "base/android/jni_array.h"
+#include "base/android/jni_string.h"
+#include "base/bind.h"
+#include "base/json/json_writer.h"
+#include "base/values.h"
+#include "brave/browser/brave_vpn/brave_vpn_service_factory.h"
+#include "brave/build/android/jni_headers/BraveVpnNativeWorker_jni.h"
+#include "brave/components/brave_vpn/brave_vpn_service.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+
+namespace {
+
+BraveVpnService* GetBraveVpnService() {
+  return BraveVpnServiceFactory::GetForProfile(
+      ProfileManager::GetActiveUserProfile()->GetOriginalProfile());
+}
+
+}  // namespace
+
+namespace chrome {
+namespace android {
+
+BraveVpnNativeWorker::BraveVpnNativeWorker(
+    JNIEnv* env,
+    const base::android::JavaRef<jobject>& obj)
+    : weak_java_brave_vpn_native_worker_(env, obj), weak_factory_(this) {
+  Java_BraveVpnNativeWorker_setNativePtr(env, obj,
+                                         reinterpret_cast<intptr_t>(this));
+}
+
+BraveVpnNativeWorker::~BraveVpnNativeWorker() {}
+
+void BraveVpnNativeWorker::Destroy(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller) {
+  delete this;
+}
+
+void BraveVpnNativeWorker::GetAllServerRegions(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller) {
+  BraveVpnService* brave_vpn_service = GetBraveVpnService();
+  if (brave_vpn_service) {
+    brave_vpn_service->GetAllServerRegions(
+        base::BindOnce(&BraveVpnNativeWorker::OnGetAllServerRegions,
+                       weak_factory_.GetWeakPtr()));
+  }
+}
+
+void BraveVpnNativeWorker::OnGetAllServerRegions(
+    const std::string& server_regions_json,
+    bool success) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_BraveVpnNativeWorker_onGetAllServerRegions(
+      env, weak_java_brave_vpn_native_worker_.get(env),
+      base::android::ConvertUTF8ToJavaString(env, server_regions_json),
+      success);
+}
+
+void BraveVpnNativeWorker::GetTimezonesForRegions(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller) {
+  BraveVpnService* brave_vpn_service = GetBraveVpnService();
+  if (brave_vpn_service) {
+    brave_vpn_service->GetTimezonesForRegions(
+        base::BindOnce(&BraveVpnNativeWorker::OnGetTimezonesForRegions,
+                       weak_factory_.GetWeakPtr()));
+  }
+}
+
+void BraveVpnNativeWorker::OnGetTimezonesForRegions(
+    const std::string& timezones_json,
+    bool success) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_BraveVpnNativeWorker_onGetTimezonesForRegions(
+      env, weak_java_brave_vpn_native_worker_.get(env),
+      base::android::ConvertUTF8ToJavaString(env, timezones_json), success);
+}
+
+void BraveVpnNativeWorker::GetHostnamesForRegion(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller,
+    const base::android::JavaParamRef<jstring>& region) {
+  BraveVpnService* brave_vpn_service = GetBraveVpnService();
+  if (brave_vpn_service) {
+    brave_vpn_service->GetHostnamesForRegion(
+        base::BindOnce(&BraveVpnNativeWorker::OnGetHostnamesForRegion,
+                       weak_factory_.GetWeakPtr()),
+        base::android::ConvertJavaStringToUTF8(env, region));
+  }
+}
+
+void BraveVpnNativeWorker::OnGetHostnamesForRegion(
+    const std::string& hostnames_json,
+    bool success) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_BraveVpnNativeWorker_onGetHostnamesForRegion(
+      env, weak_java_brave_vpn_native_worker_.get(env),
+      base::android::ConvertUTF8ToJavaString(env, hostnames_json), success);
+}
+
+void BraveVpnNativeWorker::GetSubscriberCredential(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller,
+    const base::android::JavaParamRef<jstring>& product_type,
+    const base::android::JavaParamRef<jstring>& product_id,
+    const base::android::JavaParamRef<jstring>& validation_method,
+    const base::android::JavaParamRef<jstring>& purchase_token) {
+  BraveVpnService* brave_vpn_service = GetBraveVpnService();
+  if (brave_vpn_service) {
+    brave_vpn_service->GetSubscriberCredential(
+        base::BindOnce(&BraveVpnNativeWorker::OnGetSubscriberCredential,
+                       weak_factory_.GetWeakPtr()),
+        base::android::ConvertJavaStringToUTF8(env, product_type),
+        base::android::ConvertJavaStringToUTF8(env, product_id),
+        base::android::ConvertJavaStringToUTF8(env, validation_method),
+        base::android::ConvertJavaStringToUTF8(env, purchase_token));
+  }
+}
+
+void BraveVpnNativeWorker::OnGetSubscriberCredential(
+    const std::string& subscriber_credential,
+    bool success) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_BraveVpnNativeWorker_onGetSubscriberCredential(
+      env, weak_java_brave_vpn_native_worker_.get(env),
+      base::android::ConvertUTF8ToJavaString(env, subscriber_credential),
+      success);
+}
+
+void BraveVpnNativeWorker::VerifyPurchaseToken(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller,
+    const base::android::JavaParamRef<jstring>& purchase_token,
+    const base::android::JavaParamRef<jstring>& product_id,
+    const base::android::JavaParamRef<jstring>& product_type) {
+  BraveVpnService* brave_vpn_service = GetBraveVpnService();
+  if (brave_vpn_service) {
+    brave_vpn_service->VerifyPurchaseToken(
+        base::BindOnce(&BraveVpnNativeWorker::OnVerifyPurchaseToken,
+                       weak_factory_.GetWeakPtr()),
+        base::android::ConvertJavaStringToUTF8(env, purchase_token),
+        base::android::ConvertJavaStringToUTF8(env, product_id),
+        base::android::ConvertJavaStringToUTF8(env, product_type));
+  }
+}
+
+void BraveVpnNativeWorker::OnVerifyPurchaseToken(
+    const std::string& json_response,
+    bool success) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  Java_BraveVpnNativeWorker_onVerifyPurchaseToken(
+      env, weak_java_brave_vpn_native_worker_.get(env),
+      base::android::ConvertUTF8ToJavaString(env, json_response), success);
+}
+
+static void JNI_BraveVpnNativeWorker_Init(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller) {
+  new BraveVpnNativeWorker(env, jcaller);
+}
+
+}  // namespace android
+}  // namespace chrome