Implement Networking Private API VerifyAndEncryptCredentials method

chrome/browser/extensions/api/networking_private/networking_private_service_client.cc

Index: chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
diff --git a/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc b/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
index d9925cc52a74d23f982de09c6cf1bc09280e5794..1975fca272be5fc93b1dcb7ebee6ffe8f665cd8e 100644
--- a/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
+++ b/chrome/browser/extensions/api/networking_private/networking_private_service_client.cc
@@ -11,6 +11,7 @@
 #include "base/strings/string_util.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
 #include "chrome/browser/extensions/api/networking_private/networking_private_crypto.h"
 #include "chrome/common/extensions/api/networking_private.h"
 #include "content/public/browser/browser_thread.h"
@@ -49,15 +50,38 @@ class CryptoVerifyImpl : public NetworkingPrivateServiceClient::CryptoVerify {
   virtual void VerifyDestination(scoped_ptr<base::ListValue> args,
                                  bool* verified,
                                  std::string* error) OVERRIDE {
-    using extensions::api::networking_private::VerifyDestination::Params;
+    using api::networking_private::VerifyDestination::Params;
     scoped_ptr<Params> params = Params::Create(*args);
     *verified = VerifyDestination(params->properties);
   }
 
+  virtual void VerifyAndEncryptCredentials(
+      scoped_ptr<base::ListValue> args,
+      scoped_ptr<NetworkingPrivateCredentialsGetter> credentials_getter,
+      const VerifyAndEncryptCredentialsCallback& callback) OVERRIDE {
+    using api::networking_private::VerifyAndEncryptCredentials::Params;
+    scoped_ptr<Params> params = Params::Create(*args);
+    std::string public_key;
+    std::string network_guid;
+
+    if (!VerifyDestination(params->properties)) {
+      callback.Run("", "VerifyError");
+      return;
+    }
+
+    if (!base::Base64Decode(params->properties.public_key, &public_key)) {
+      callback.Run("", "DecodeError");
+      return;
+    }
+
+    network_guid = params->guid;
+    credentials_getter->Start(network_guid, public_key, callback);
+  }
+
   virtual void VerifyAndEncryptData(scoped_ptr<base::ListValue> args,
                                     std::string* base64_encoded_ciphertext,
                                     std::string* error) OVERRIDE {
-    using extensions::api::networking_private::VerifyAndEncryptData::Params;
+    using api::networking_private::VerifyAndEncryptData::Params;
     scoped_ptr<Params> params = Params::Create(*args);
 
     if (!VerifyDestination(params->properties)) {
@@ -411,6 +435,46 @@ void NetworkingPrivateServiceClient::VerifyDestination(
                  base::Owned(error)));
 }
 
+static void AfterVerifyAndEncryptCredentialsRelayOnWorkerThread(

[tbarzic, 2014/02/25 20:40:49]

move this to namespace {}

Also, this doesn't necessary have to be called on Worker thread, so the name
should probably be changed.

[mef, 2014/02/25 22:36:26]

Done.

+    const NetworkingPrivateServiceClient::CryptoVerify::
+        VerifyAndEncryptCredentialsCallback& callback,
+    scoped_refptr<base::MessageLoopProxy> callback_loop_proxy,
+    const std::string& key_data,
+    const std::string& error) {
+  callback_loop_proxy->PostTask(FROM_HERE,
+                                base::Bind(callback, key_data, error));
+}
+
+void NetworkingPrivateServiceClient::VerifyAndEncryptCredentials(
+    scoped_ptr<base::ListValue> args,
+    const StringResultCallback& callback,
+    const CryptoErrorCallback& error_callback) {
+  ServiceCallbacks* service_callbacks = AddServiceCallbacks();
+  service_callbacks->crypto_error_callback = error_callback;
+  service_callbacks->verify_and_encrypt_credentials_callback = callback;
+
+  scoped_ptr<NetworkingPrivateCredentialsGetter> credentials_getter(

[tbarzic, 2014/02/25 20:40:49]

you can probably move the getter creation to |VerifyAndEncryptCredentials|.

[mef, 2014/02/25 22:36:26]

Done.

+      NetworkingPrivateCredentialsGetter::Create());
+
+  CryptoVerify::VerifyAndEncryptCredentialsCallback callback_relay(
+      base::Bind(
+          &AfterVerifyAndEncryptCredentialsRelayOnWorkerThread,
+          base::Bind(
+              &NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials,
+              weak_factory_.GetWeakPtr(),
+              service_callbacks->id),
+          base::MessageLoopProxy::current()));
+
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &CryptoVerify::VerifyAndEncryptCredentials,
+          base::Unretained(crypto_verify_.get()),
+          base::Passed(&args),
+          base::Passed(&credentials_getter),
+          callback_relay));
+}
+
 void NetworkingPrivateServiceClient::VerifyAndEncryptData(
     scoped_ptr<base::ListValue> args,
     const StringResultCallback& callback,
@@ -545,6 +609,25 @@ void NetworkingPrivateServiceClient::AfterVerifyDestination(
   RemoveServiceCallbacks(callback_id);
 }
 
+void NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials(
+    ServiceCallbacksID callback_id,
+    const std::string& encrypted_data,
+    const std::string& error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
+  DCHECK(service_callbacks);
+  if (!error.empty()) {
+    DCHECK(!service_callbacks->crypto_error_callback.is_null());
+    service_callbacks->crypto_error_callback.Run(error, error);
+  } else {
+    DCHECK(
+        !service_callbacks->verify_and_encrypt_credentials_callback.is_null());
+    service_callbacks->verify_and_encrypt_credentials_callback.Run(
+        encrypted_data);
+  }
+  RemoveServiceCallbacks(callback_id);
+}
+
 void NetworkingPrivateServiceClient::AfterVerifyAndEncryptData(
     ServiceCallbacksID callback_id,
     const std::string* result,