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..db2610f35d256b92d684809b96c39f75e36d6c94 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,43 @@ 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,
+      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;
+    }
+
+    scoped_ptr<NetworkingPrivateCredentialsGetter> credentials_getter(
+      NetworkingPrivateCredentialsGetter::Create());
+
+    network_guid = params->guid;
+    // Start getting credentials. On Windows |callback| will be called
+    // asynchronously on a different thread after |credentials_getter|
+    // is deleted.
+    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 +440,44 @@ void NetworkingPrivateServiceClient::VerifyDestination(
                  base::Owned(error)));
 }
 
+namespace {
+void AfterVerifyAndEncryptCredentialsRelay(

[tbarzic, 2014/02/25 23:07:25]

nit: move this to line 121

[mef, 2014/02/26 17:43:36]

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));
+}
+}  // namespace
+
+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;
+
+  CryptoVerify::VerifyAndEncryptCredentialsCallback callback_relay(
+      base::Bind(
+          &AfterVerifyAndEncryptCredentialsRelay,
+          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),
+          callback_relay));
+}
+
 void NetworkingPrivateServiceClient::VerifyAndEncryptData(
     scoped_ptr<base::ListValue> args,
     const StringResultCallback& callback,
@@ -545,6 +612,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,