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..ee0054894f656d1ec7c30ed782ddd4cb16779c54 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
@@ -49,15 +49,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,
+      NetworkingPrivateCredentialsGetter* credentials_getter) 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)) {
+      credentials_getter->ReportResult("", "VerifyError");
+      return;
+    }
+
+    if (!base::Base64Decode(params->properties.public_key, &public_key)) {
+      credentials_getter->ReportResult("", "DecodeError");
+      return;
+    }
+
+    network_guid = params->guid;
+    credentials_getter->Start(network_guid, public_key);
+  }
+
   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 +434,29 @@ void NetworkingPrivateServiceClient::VerifyDestination(
                  base::Owned(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;
+
+  service_callbacks->credentials_getter.reset(
+    NetworkingPrivateCredentialsGetter::Create(
+        base::Bind(
+            &NetworkingPrivateServiceClient::AfterVerifyAndEncryptCredentials,
+            weak_factory_.GetWeakPtr(),
+            service_callbacks->id)));
+
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&CryptoVerify::VerifyAndEncryptCredentials,
+          base::Unretained(crypto_verify_.get()),
+          base::Passed(&args),
+          base::Unretained(service_callbacks->credentials_getter.get())));
+}
+
 void NetworkingPrivateServiceClient::VerifyAndEncryptData(
     scoped_ptr<base::ListValue> args,
     const StringResultCallback& callback,
@@ -545,6 +591,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,