Remove networkingPrivate.verifyAndEncryptCredentials

This was intended to enable auto-filling network credentials during
Chromecast setup, but never actually caught on (i.e. it has not been
actually used).

BUG=846971

Change-Id: I66e5e316ec91eac0c286f82aa4aad1573ed931f8
Reviewed-on: https://chromium-review.googlesource.com/c/1297407
Commit-Queue: Toni Baržić <tbarzic@chromium.org>
Reviewed-by: Steven Bennetts <stevenjb@chromium.org>
Cr-Commit-Position: refs/heads/master@{#603770}

chrome/browser/extensions/BUILD.gn

@@ -252,7 +252,6 @@ jumbo_static_library("extensions") {
     "api/metrics_private/chrome_metrics_private_delegate.h",
     "api/module/module.cc",
     "api/module/module.h",
-    "api/networking_private/networking_private_credentials_getter_chromeos.cc",
     "api/networking_private/networking_private_ui_delegate_chromeos.cc",
     "api/networking_private/networking_private_ui_delegate_chromeos.h",
     "api/networking_private/networking_private_ui_delegate_factory_impl.cc",
@@ -1051,9 +1050,6 @@ jumbo_static_library("extensions") {
       "api/networking_cast_private/chrome_networking_cast_private_delegate.h",
       "api/networking_cast_private/networking_cast_private_api.cc",
       "api/networking_cast_private/networking_cast_private_api.h",
-      "api/networking_private/networking_private_credentials_getter.h",
-      "api/networking_private/networking_private_credentials_getter_mac.cc",
-      "api/networking_private/networking_private_credentials_getter_win.cc",
     ]
     deps += [ "//components/wifi" ]
   }

chrome/browser/extensions/api/networking_cast_private/chrome_networking_cast_private_delegate.cc

@@ -15,7 +15,6 @@
 #include "base/strings/string_util.h"
 #include "base/task/post_task.h"
 #include "base/threading/thread_task_runner_handle.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 "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
@@ -111,62 +110,6 @@ void VerifyAndEncryptDataCompleted(
     success_callback.Run(encrypted_data);
 }
 
-// Called when NetworkingPrivateCredentialsGetter completes (from an arbitrary
-// thread). Posts the result to the UI thread.
-void CredentialsGetterCompleted(
-    const NetworkingCastPrivateDelegate::DataCallback& success_callback,
-    const NetworkingCastPrivateDelegate::FailureCallback& failure_callback,
-    const std::string& key_data,
-    const std::string& error) {
-  if (!error.empty()) {
-    base::PostTaskWithTraits(FROM_HERE, {content::BrowserThread::UI},
-                             base::BindOnce(failure_callback, error));
-  } else {
-    base::PostTaskWithTraits(FROM_HERE, {content::BrowserThread::UI},
-                             base::BindOnce(success_callback, key_data));
-  }
-}
-
-// Called from a blocking pool task runner. Returns true if
-// NetworkingPrivateCredentialsGetter is successfully started (which will
-// invoke the appropriate callback when completed), or false if unable
-// to start the getter (credentials or public key decode failed).
-bool RunVerifyAndEncryptCredentials(
-    const std::string& guid,
-    std::unique_ptr<NetworkingCastPrivateDelegate::Credentials> credentials,
-    const NetworkingCastPrivateDelegate::DataCallback& success_callback,
-    const NetworkingCastPrivateDelegate::FailureCallback& failure_callback) {
-  if (DecodeAndVerifyCredentials(*credentials) != VerificationResult::SUCCESS)
-    return false;
-
-  std::string decoded_public_key;
-  if (!base::Base64Decode(credentials->public_key(), &decoded_public_key)) {
-    LOG(ERROR) << "Failed to decode public key";
-    return false;
-  }
-
-  // Start getting credentials. CredentialsGetterCompleted will be called on
-  // completion. On Windows it will be called from a different thread after
-  // |credentials_getter| is deleted.
-  std::unique_ptr<NetworkingPrivateCredentialsGetter> credentials_getter(
-      NetworkingPrivateCredentialsGetter::Create());
-  credentials_getter->Start(guid, decoded_public_key,
-                            base::Bind(&CredentialsGetterCompleted,
-                                       success_callback, failure_callback));
-  return true;
-}
-
-void VerifyAndEncryptCredentialsCompleted(
-    const NetworkingCastPrivateDelegate::FailureCallback& failure_callback,
-    bool succeeded) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  // If VerifyAndEncryptCredentials succeeded, then the appropriate callback
-  // will be triggered from CredentialsGetterCompleted.
-  if (succeeded)
-    return;
-  failure_callback.Run(kErrorEncryptionError);
-}
-
 }  // namespace
 
 std::unique_ptr<ChromeNetworkingCastPrivateDelegate>
@@ -197,19 +140,6 @@ void ChromeNetworkingCastPrivateDelegate::VerifyDestination(
                  failure_callback));
 }
 
-void ChromeNetworkingCastPrivateDelegate::VerifyAndEncryptCredentials(
-    const std::string& guid,
-    std::unique_ptr<Credentials> credentials,
-    const DataCallback& success_callback,
-    const FailureCallback& failure_callback) {
-  base::PostTaskWithTraitsAndReplyWithResult(
-      FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
-      base::Bind(&RunVerifyAndEncryptCredentials, guid,
-                 base::Passed(&credentials), success_callback,
-                 failure_callback),
-      base::Bind(&VerifyAndEncryptCredentialsCompleted, failure_callback));
-}
-
 void ChromeNetworkingCastPrivateDelegate::VerifyAndEncryptData(
     const std::string& data,
     std::unique_ptr<Credentials> credentials,

chrome/browser/extensions/api/networking_cast_private/chrome_networking_cast_private_delegate.h

@@ -30,11 +30,6 @@ class ChromeNetworkingCastPrivateDelegate
   void VerifyDestination(std::unique_ptr<Credentials> credentials,
                          const VerifiedCallback& success_callback,
                          const FailureCallback& failure_callback) override;
-  void VerifyAndEncryptCredentials(
-      const std::string& guid,
-      std::unique_ptr<Credentials> credentials,
-      const DataCallback& success_callback,
-      const FailureCallback& failure_callback) override;
   void VerifyAndEncryptData(const std::string& data,
                             std::unique_ptr<Credentials> credentials,
                             const DataCallback& success_callback,

chrome/browser/extensions/api/networking_cast_private/networking_cast_private_api.cc

@@ -88,41 +88,6 @@ void NetworkingCastPrivateVerifyDestinationFunction::Failure(
   Respond(Error(error));
 }
 
-NetworkingCastPrivateVerifyAndEncryptCredentialsFunction::
-    ~NetworkingCastPrivateVerifyAndEncryptCredentialsFunction() {}
-
-ExtensionFunction::ResponseAction
-NetworkingCastPrivateVerifyAndEncryptCredentialsFunction::Run() {
-  std::unique_ptr<cast_api::VerifyAndEncryptCredentials::Params> params =
-      cast_api::VerifyAndEncryptCredentials::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(params);
-
-  NetworkingCastPrivateDelegate* delegate =
-      ExtensionsAPIClient::Get()->GetNetworkingCastPrivateDelegate();
-  delegate->VerifyAndEncryptCredentials(
-      params->network_guid, AsCastCredentials(params->properties),
-      base::Bind(
-          &NetworkingCastPrivateVerifyAndEncryptCredentialsFunction::Success,
-          this),
-      base::Bind(
-          &NetworkingCastPrivateVerifyAndEncryptCredentialsFunction::Failure,
-          this));
-
-  // VerifyAndEncryptCredentials might respond synchronously, e.g. in tests.
-  return did_respond() ? AlreadyResponded() : RespondLater();
-}
-
-void NetworkingCastPrivateVerifyAndEncryptCredentialsFunction::Success(
-    const std::string& result) {
-  Respond(ArgumentList(
-      cast_api::VerifyAndEncryptCredentials::Results::Create(result)));
-}
-
-void NetworkingCastPrivateVerifyAndEncryptCredentialsFunction::Failure(
-    const std::string& error) {
-  Respond(Error(error));
-}
-
 NetworkingCastPrivateVerifyAndEncryptDataFunction::
     ~NetworkingCastPrivateVerifyAndEncryptDataFunction() {}
 

chrome/browser/extensions/api/networking_cast_private/networking_cast_private_api.h

@@ -37,28 +37,6 @@ class NetworkingCastPrivateVerifyDestinationFunction
   DISALLOW_COPY_AND_ASSIGN(NetworkingCastPrivateVerifyDestinationFunction);
 };
 
-class NetworkingCastPrivateVerifyAndEncryptCredentialsFunction
-    : public UIThreadExtensionFunction {
- public:
-  NetworkingCastPrivateVerifyAndEncryptCredentialsFunction() {}
-  DECLARE_EXTENSION_FUNCTION(
-      "networking.castPrivate.verifyAndEncryptCredentials",
-      NETWORKINGCASTPRIVATE_VERIFYANDENCRYPTCREDENTIALS);
-
- protected:
-  ~NetworkingCastPrivateVerifyAndEncryptCredentialsFunction() override;
-
-  // ExtensionFunction:
-  ResponseAction Run() override;
-
-  void Success(const std::string& result);
-  void Failure(const std::string& error);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(
-      NetworkingCastPrivateVerifyAndEncryptCredentialsFunction);
-};
-
 class NetworkingCastPrivateVerifyAndEncryptDataFunction
     : public UIThreadExtensionFunction {
  public:

chrome/browser/extensions/api/networking_cast_private/networking_cast_private_apitest.cc

@@ -42,15 +42,6 @@ class TestNetworkingCastPrivateDelegate
     success_callback.Run(true);
   }
 
-  void VerifyAndEncryptCredentials(
-      const std::string& guid,
-      std::unique_ptr<Credentials> credentials,
-      const DataCallback& success_callback,
-      const FailureCallback& failure_callback) override {
-    AssertCredentials(*credentials);
-    success_callback.Run("encrypted_credentials");
-  }
-
   void VerifyAndEncryptData(const std::string& data,
                             std::unique_ptr<Credentials> credentials,
                             const DataCallback& success_callback,

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

@@ -291,17 +291,6 @@ class TestNetworkingCastPrivateDelegate
     }
   }
 
-  void VerifyAndEncryptCredentials(
-      const std::string& guid,
-      std::unique_ptr<Credentials> credentials,
-      const DataCallback& success_callback,
-      const FailureCallback& failure_callback) override {
-    if (fail_) {
-      failure_callback.Run(kFailure);
-    } else {
-      success_callback.Run("encrypted_credentials");
-    }
-  }
   void VerifyAndEncryptData(const std::string& data,
                             std::unique_ptr<Credentials> credentials,
                             const DataCallback& success_callback,
@@ -493,10 +482,6 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, VerifyDestination) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyDestination")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, VerifyAndEncryptCredentials) {
-  EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
-}
-
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, VerifyAndEncryptData) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 }
@@ -603,11 +588,6 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, VerifyDestination) {
   EXPECT_FALSE(RunNetworkingSubtest("verifyDestination")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail,
-                       VerifyAndEncryptCredentials) {
-  EXPECT_FALSE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
-}
-
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, VerifyAndEncryptData) {
   EXPECT_FALSE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 }

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

@@ -17,7 +17,6 @@
 #include "chrome/browser/chromeos/login/helper.h"
 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
 #include "chrome/browser/extensions/api/networking_cast_private/chrome_networking_cast_private_delegate.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
 #include "chrome/browser/extensions/api/networking_private/networking_private_ui_delegate_chromeos.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chromeos/chromeos_switches.h"
@@ -114,15 +113,6 @@ class TestNetworkingCastPrivateDelegate
     success_callback.Run(true);
   }
 
-  void VerifyAndEncryptCredentials(
-      const std::string& guid,
-      std::unique_ptr<Credentials> credentials,
-      const DataCallback& success_callback,
-      const FailureCallback& failure_callback) override {
-    AssertCredentials(*credentials);
-    success_callback.Run("encrypted_credentials");
-  }
-
   void VerifyAndEncryptData(const std::string& data,
                             std::unique_ptr<Credentials> credentials,
                             const DataCallback& success_callback,
@@ -836,11 +826,6 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, VerifyDestination) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyDestination")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
-                       VerifyAndEncryptCredentials) {
-  EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
-}
-
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, VerifyAndEncryptData) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;
 }

chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_CREDENTIALS_GETTER_H_
-#define CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_CREDENTIALS_GETTER_H_
-
-#include <string>
-
-#include "base/callback.h"
-#include "base/macros.h"
-
-namespace extensions {
-
-// NetworkingPrivateCredentialsGetter gets plain-text WiFi credentials from the
-// system and encrypts it with public key.
-class NetworkingPrivateCredentialsGetter {
- public:
-  typedef base::Callback<void(const std::string& key_data,
-                              const std::string& error)> CredentialsCallback;
-
-  static NetworkingPrivateCredentialsGetter* Create();
-
-  NetworkingPrivateCredentialsGetter() {}
-
-  virtual ~NetworkingPrivateCredentialsGetter() {}
-
-  // Starts getting credentials. The credentials and, in case of an error, the
-  // error code are returned using |callback|.
-  // The NetworkingPrivateCredentialsGetter implementation should ensure that
-  // the credentials request can be successfully processed even if |this| gets
-  // deleted immediately after calling this method.
-  // Note that there are no guarantees about the thread on which |callback| is
-  // run. The caller should make sure that the result is processed on the right
-  // thread.
-  virtual void Start(const std::string& network_guid,
-                     const std::string& public_key,
-                     const CredentialsCallback& callback) = 0;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateCredentialsGetter);
-};
-
-}  // namespace extensions
-
-#endif  // CHROME_BROWSER_EXTENSIONS_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_CREDENTIALS_GETTER_H_

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

-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/macros.h"
-#include "base/run_loop.h"
-#include "base/task/post_task.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
-#include "chrome/services/wifi_util_win/public/mojom/wifi_credentials_getter.mojom.h"
-#include "chrome/test/base/in_process_browser_test.h"
-#include "content/public/browser/browser_task_traits.h"
-#include "content/public/browser/browser_thread.h"
-
-#if !defined(OS_WIN)
-#error This test is OS_WIN only.
-#endif
-
-class NetworkingPrivateCredentialsGetterTest : public InProcessBrowserTest {
- public:
-  NetworkingPrivateCredentialsGetterTest() = default;
-
-  void RunTest(bool use_test_network) {
-    base::RunLoop run_loop;
-    quit_closure_ = run_loop.QuitClosure();
-
-    if (use_test_network)
-      network_ = chrome::mojom::WiFiCredentialsGetter::kWiFiTestNetwork;
-
-    done_called_ = false;
-    base::PostTaskWithTraits(
-        FROM_HERE, {base::MayBlock(), base::TaskPriority::BEST_EFFORT},
-        base::Bind(&NetworkingPrivateCredentialsGetterTest::GetCredentials,
-                   base::Unretained(this)));
-    run_loop.Run();
-
-    EXPECT_TRUE(done_called_);
-  }
-
- private:
-  void GetCredentials() {
-    std::unique_ptr<extensions::NetworkingPrivateCredentialsGetter> getter(
-        extensions::NetworkingPrivateCredentialsGetter::Create());
-    getter->Start(
-        network_, "public_key",
-        base::Bind(&NetworkingPrivateCredentialsGetterTest::CredentialsDone,
-                   base::Unretained(this)));
-  }
-
-  void CredentialsDone(const std::string& key_data, const std::string& error) {
-    done_called_ = true;
-
-    if (!network_.empty()) {
-      EXPECT_EQ(network_, key_data);
-      EXPECT_EQ("", error);
-    } else {
-      EXPECT_EQ("", key_data);
-      EXPECT_FALSE(error.empty());
-    }
-
-    base::PostTaskWithTraits(FROM_HERE, {content::BrowserThread::UI},
-                             quit_closure_);
-  }
-
-  base::Closure quit_closure_;
-  std::string network_;
-  bool done_called_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateCredentialsGetterTest);
-};
-
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateCredentialsGetterTest,
-                       GetCredentialsSuccess) {
-  RunTest(true);
-}
-
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateCredentialsGetterTest,
-                       GetCredentialsFailure) {
-  RunTest(false);
-}

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

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "base/macros.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
-
-const char kErrorNotImplemented[] = "Error.NotImplemented";
-
-namespace extensions {
-
-class NetworkingPrivateCredentialsGetterChromeos
-    : public NetworkingPrivateCredentialsGetter {
- public:
-  NetworkingPrivateCredentialsGetterChromeos() {}
-
-  void Start(const std::string& network_guid,
-             const std::string& public_key,
-             const CredentialsCallback& callback) override;
-
- private:
-  ~NetworkingPrivateCredentialsGetterChromeos() override;
-
-  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateCredentialsGetterChromeos);
-};
-
-NetworkingPrivateCredentialsGetterChromeos::
-    ~NetworkingPrivateCredentialsGetterChromeos() {
-}
-
-void NetworkingPrivateCredentialsGetterChromeos::Start(
-    const std::string& network_guid,
-    const std::string& public_key,
-    const CredentialsCallback& callback) {
-  // TODO(sheretov) add credential slurping from sync.
-  callback.Run(std::string(), kErrorNotImplemented);
-}
-
-NetworkingPrivateCredentialsGetter*
-NetworkingPrivateCredentialsGetter::Create() {
-  return new NetworkingPrivateCredentialsGetterChromeos();
-}
-
-}  // namespace extensions

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

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
-
-#include <Security/Security.h>
-#include <stdint.h>
-
-#include <memory>
-
-#include "base/base64.h"
-#include "base/bind.h"
-#include "base/macros.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_crypto.h"
-#include "components/wifi/wifi_service.h"
-#include "content/public/browser/browser_thread.h"
-
-const char kErrorEncryption[] = "Error.Encryption";
-
-using content::BrowserThread;
-
-namespace extensions {
-
-class NetworkingPrivateCredentialsGetterMac
-    : public NetworkingPrivateCredentialsGetter {
- public:
-  explicit NetworkingPrivateCredentialsGetterMac();
-
-  void Start(const std::string& network_guid,
-             const std::string& public_key,
-             const CredentialsCallback& callback) override;
-
- private:
-  ~NetworkingPrivateCredentialsGetterMac() override;
-
-  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateCredentialsGetterMac);
-};
-
-NetworkingPrivateCredentialsGetterMac::NetworkingPrivateCredentialsGetterMac() {
-}
-
-NetworkingPrivateCredentialsGetterMac::
-    ~NetworkingPrivateCredentialsGetterMac() {}
-
-void NetworkingPrivateCredentialsGetterMac::Start(
-    const std::string& network_guid,
-    const std::string& public_key,
-    const CredentialsCallback& callback) {
-  std::unique_ptr<wifi::WiFiService> wifi_service(wifi::WiFiService::Create());
-  wifi_service->Initialize(NULL);
-  std::string key_data;
-  std::string error;
-  wifi_service->GetKeyFromSystem(network_guid, &key_data, &error);
-
-  if (!error.empty()) {
-    callback.Run("", error);
-    return;
-  }
-
-  std::vector<uint8_t> public_key_data(public_key.begin(), public_key.end());
-  std::vector<uint8_t> ciphertext;
-  if (!networking_private_crypto::EncryptByteString(
-          public_key_data, key_data, &ciphertext)) {
-    callback.Run("", kErrorEncryption);
-    return;
-  }
-
-  std::string base64_encoded_ciphertext;
-  base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(ciphertext.data()),
-                        ciphertext.size()),
-      &base64_encoded_ciphertext);
-  callback.Run(base64_encoded_ciphertext, "");
-}
-
-NetworkingPrivateCredentialsGetter*
-NetworkingPrivateCredentialsGetter::Create() {
-  return new NetworkingPrivateCredentialsGetterMac();
-}
-
-}  // namespace extensions

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

-// Copyright 2014 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
-
-#include <stdint.h>
-
-#include "base/base64.h"
-#include "base/bind.h"
-#include "base/macros.h"
-#include "base/strings/string_piece.h"
-#include "base/task/post_task.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_crypto.h"
-#include "chrome/services/wifi_util_win/public/mojom/constants.mojom.h"
-#include "chrome/services/wifi_util_win/public/mojom/wifi_credentials_getter.mojom.h"
-#include "content/public/browser/browser_task_traits.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/common/service_manager_connection.h"
-#include "services/service_manager/public/cpp/connector.h"
-
-namespace {
-
-using extensions::NetworkingPrivateCredentialsGetter;
-
-class CredentialsGetterHostClient {
- public:
-  static CredentialsGetterHostClient* Create(const std::string& public_key) {
-    return new CredentialsGetterHostClient(public_key);
-  }
-
-  void GetWiFiCredentialsOnIOThread(
-      const std::string& network_guid,
-      const NetworkingPrivateCredentialsGetter::CredentialsCallback& callback,
-      std::unique_ptr<service_manager::Connector> connector);
-
- private:
-  explicit CredentialsGetterHostClient(const std::string& public_key)
-      : public_key_(public_key.begin(), public_key.end()) {}
-
-  ~CredentialsGetterHostClient() = default;
-
-  // Credentials result handler.
-  void GetWiFiCredentialsDone(bool success, const std::string& key_data);
-
-  // Report the result to |callback_|.
-  void ReportResult(bool success, const std::string& key_data);
-
-  // Public key used to encrypt the result.
-  std::vector<uint8_t> public_key_;
-
-  // Callback for reporting the encrypted result.
-  NetworkingPrivateCredentialsGetter::CredentialsCallback callback_;
-
-  // Utility process used to get the credentials.
-  chrome::mojom::WiFiCredentialsGetterPtr wifi_credentials_getter_;
-
-  // WiFi network to get the credentials from.
-  std::string wifi_network_;
-
-  DISALLOW_COPY_AND_ASSIGN(CredentialsGetterHostClient);
-};
-
-void CredentialsGetterHostClient::GetWiFiCredentialsOnIOThread(
-    const std::string& network_guid,
-    const NetworkingPrivateCredentialsGetter::CredentialsCallback& callback,
-    std::unique_ptr<service_manager::Connector> connector) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  DCHECK(!wifi_credentials_getter_);
-  DCHECK(!callback.is_null());
-
-  wifi_network_ = network_guid;
-  callback_ = callback;
-
-  connector->BindInterface(chrome::mojom::kWifiUtilWinServiceName,
-                           &wifi_credentials_getter_);
-
-  wifi_credentials_getter_.set_connection_error_handler(
-      base::Bind(&CredentialsGetterHostClient::GetWiFiCredentialsDone,
-                 base::Unretained(this), false, std::string()));
-  wifi_credentials_getter_->GetWiFiCredentials(
-      wifi_network_,
-      base::Bind(&CredentialsGetterHostClient::GetWiFiCredentialsDone,
-                 base::Unretained(this)));
-}
-
-void CredentialsGetterHostClient::GetWiFiCredentialsDone(
-    bool success,
-    const std::string& key_data) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-
-  wifi_credentials_getter_.reset();
-  ReportResult(success, key_data);
-  delete this;
-}
-
-void CredentialsGetterHostClient::ReportResult(bool success,
-                                               const std::string& key_data) {
-  if (!success) {
-    callback_.Run(std::string(), "Get Credentials Failed");
-    return;
-  }
-
-  if (wifi_network_ == chrome::mojom::WiFiCredentialsGetter::kWiFiTestNetwork) {
-    DCHECK_EQ(wifi_network_, key_data);
-    callback_.Run(key_data, std::string());
-    return;
-  }
-
-  std::vector<uint8_t> ciphertext;
-  if (!networking_private_crypto::EncryptByteString(public_key_, key_data,
-                                                    &ciphertext)) {
-    callback_.Run(std::string(), "Encrypt Credentials Failed");
-    return;
-  }
-
-  std::string base64_encoded_key_data;
-  base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(ciphertext.data()),
-                        ciphertext.size()),
-      &base64_encoded_key_data);
-  callback_.Run(base64_encoded_key_data, std::string());
-}
-
-}  // namespace
-
-namespace extensions {
-
-class NetworkingPrivateCredentialsGetterWin
-    : public NetworkingPrivateCredentialsGetter {
- public:
-  NetworkingPrivateCredentialsGetterWin() = default;
-
-  void Start(const std::string& network_guid,
-             const std::string& public_key,
-             const CredentialsCallback& callback) override {
-    // Bounce to the UI thread to retrieve a service_manager::Connector.
-    base::PostTaskWithTraits(
-        FROM_HERE, {content::BrowserThread::UI},
-        base::Bind(&NetworkingPrivateCredentialsGetterWin::StartOnUIThread,
-                   network_guid, public_key, callback));
-  }
-
- private:
-  ~NetworkingPrivateCredentialsGetterWin() override = default;
-
-  static void StartOnUIThread(const std::string& network_guid,
-                              const std::string& public_key,
-                              const CredentialsCallback& callback) {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-
-    std::unique_ptr<service_manager::Connector> connector =
-        content::ServiceManagerConnection::GetForProcess()
-            ->GetConnector()
-            ->Clone();
-    base::PostTaskWithTraits(
-        FROM_HERE, {content::BrowserThread::IO},
-        base::BindOnce(
-            &NetworkingPrivateCredentialsGetterWin::GetCredentialsOnIOThread,
-            network_guid, public_key, callback, std::move(connector)));
-  }
-
-  static void GetCredentialsOnIOThread(
-      const std::string& network_guid,
-      const std::string& public_key,
-      const CredentialsCallback& callback,
-      std::unique_ptr<service_manager::Connector> connector) {
-    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-
-    // CredentialsGetterHostClient is self deleting.
-    CredentialsGetterHostClient* client =
-        CredentialsGetterHostClient::Create(public_key);
-    client->GetWiFiCredentialsOnIOThread(network_guid, callback,
-                                         std::move(connector));
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateCredentialsGetterWin);
-};
-
-NetworkingPrivateCredentialsGetter*
-NetworkingPrivateCredentialsGetter::Create() {
-  return new NetworkingPrivateCredentialsGetterWin();
-}
-
-}  // namespace extensions

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

@@ -11,7 +11,6 @@
 #include "base/macros.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/networking_cast_private/chrome_networking_cast_private_delegate.h"
-#include "chrome/browser/extensions/api/networking_private/networking_private_credentials_getter.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
@@ -58,15 +57,6 @@ class TestNetworkingCastPrivateDelegate
     success_callback.Run(true);
   }
 
-  void VerifyAndEncryptCredentials(
-      const std::string& guid,
-      std::unique_ptr<Credentials> credentials,
-      const DataCallback& success_callback,
-      const FailureCallback& failure_callback) override {
-    AssertCredentials(*credentials);
-    success_callback.Run("encrypted_credentials");
-  }
-
   void VerifyAndEncryptData(const std::string& data,
                             std::unique_ptr<Credentials> credentials,
                             const DataCallback& success_callback,
@@ -255,11 +245,6 @@ IN_PROC_BROWSER_TEST_F(NetworkingPrivateServiceClientApiTest,
   EXPECT_TRUE(RunNetworkingSubtest("verifyDestination")) << message_;
 }
 
-IN_PROC_BROWSER_TEST_F(NetworkingPrivateServiceClientApiTest,
-                       VerifyAndEncryptCredentials) {
-  EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptCredentials")) << message_;
-}
-
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateServiceClientApiTest,
                        VerifyAndEncryptData) {
   EXPECT_TRUE(RunNetworkingSubtest("verifyAndEncryptData")) << message_;

chrome/common/extensions/api/networking_cast_private.idl

@@ -67,17 +67,6 @@
     static void verifyDestination(VerificationProperties properties,
                                   BooleanCallback callback);
 
-    // Verifies that the device is a trusted device and retrieves encrypted
-    // network credentials.
-    // |properties|: Properties of the destination to use in verifying that it
-    //     is a trusted device.
-    // |networkGuid|: The GUID of the Cellular network to activate.
-    // |callback|: A callback function that receives base64-encoded encrypted
-    //     credential data to send to a trusted device.
-    static void verifyAndEncryptCredentials(VerificationProperties properties,
-                                            DOMString networkGuid,
-                                            StringCallback callback);
-
     // Verifies that the device is a trusted device and encrypts supplied
     // data with device public key.
     // |properties|: Properties of the destination to use in verifying that it

chrome/test/BUILD.gn

@@ -1987,7 +1987,6 @@ test("browser_tests") {
     if (is_win) {
       sources += [
         "../browser/browser_switcher/browser_switcher_service_browsertest.cc",
-        "../browser/extensions/api/networking_private/networking_private_credentials_getter_browsertest.cc",
         "../browser/printing/pdf_to_emf_converter_browsertest.cc",
         "../browser/ui/views/accessibility/invert_bubble_view_browsertest.cc",
         "../browser/ui/views/settings_reset_prompt_dialog_browsertest.cc",

chrome/test/data/extensions/api_test/networking_cast_private/test.js

@@ -30,15 +30,6 @@ chrome.test.getConfig(function(config) {
             assertTrue(isValid);
           }));
     },
-    function verifyAndEncryptCredentials() {
-      var networkGuid = 'wifi_guid';
-      chrome.networking.castPrivate.verifyAndEncryptCredentials(
-          verificationProperties,
-          networkGuid,
-          callbackPass(function(result) {
-            assertEq('encrypted_credentials', result);
-          }));
-    },
     function verifyAndEncryptData() {
       chrome.networking.castPrivate.verifyAndEncryptData(
           verificationProperties,

chrome/test/data/extensions/api_test/networking_private/alias/test.js

@@ -96,9 +96,6 @@ chrome.test.runTests([
       };
       chrome.networking.onc.verifyDestination(
           stubVerificationProperties, chrome.test.callbackFail(expectedError));
-      chrome.networking.onc.verifyAndEncryptCredentials(
-          stubVerificationProperties, '',
-          chrome.test.callbackFail(expectedError));
       chrome.networking.onc.verifyAndEncryptData(
           stubVerificationProperties, '',
           chrome.test.callbackFail(expectedError));

chrome/test/data/extensions/api_test/networking_private/chromeos/test.js

@@ -896,15 +896,6 @@ var availableTests = [
         assertTrue(isValid);
       }));
   },
-  function verifyAndEncryptCredentials() {
-    var network_guid = 'stub_wifi2_guid';
-    chrome.networkingPrivate.verifyAndEncryptCredentials(
-      verificationProperties,
-      network_guid,
-      callbackPass(function(result) {
-        assertEq('encrypted_credentials', result);
-      }));
-  },
   function verifyAndEncryptData() {
     chrome.networkingPrivate.verifyAndEncryptData(
       verificationProperties,

chrome/test/data/extensions/api_test/networking_private/service_client/test.js

@@ -431,15 +431,6 @@ var availableTests = [
         assertTrue(isValid);
       }));
   },
-  function verifyAndEncryptCredentials() {
-    var network_guid = "stub_wifi2_guid";
-    chrome.networkingPrivate.verifyAndEncryptCredentials(
-      verificationProperties,
-      network_guid,
-      callbackPass(function(result) {
-        assertEq("encrypted_credentials", result);
-      }));
-  },
   function verifyAndEncryptData() {
     chrome.networkingPrivate.verifyAndEncryptData(
       verificationProperties,

chrome/test/data/extensions/api_test/networking_private/test.js

@@ -99,10 +99,6 @@ var availableTests = [
     chrome.networkingPrivate.verifyDestination(
         verificationProperties, callbackPass(callbackResult));
   },
-  function verifyAndEncryptCredentials() {
-    chrome.networkingPrivate.verifyAndEncryptCredentials(
-        verificationProperties, kGuid, callbackPass(callbackResult));
-  },
   function verifyAndEncryptData() {
     chrome.networkingPrivate.verifyAndEncryptData(
         verificationProperties, 'data', callbackPass(callbackResult));

extensions/browser/api/networking_private/networking_cast_private_delegate.h

@@ -70,16 +70,6 @@ class NetworkingCastPrivateDelegate {
                                  const VerifiedCallback& success_callback,
                                  const FailureCallback& failure_callback) = 0;
 
-  // Verifies that data provided in |credentials| authenticates a cast device.
-  // If the device is verified as a cast device, it fetches credentials of the
-  // network identified with |network_guid| and returns the network credentials
-  // encrypted with a public key derived from |credentials|.
-  virtual void VerifyAndEncryptCredentials(
-      const std::string& network_guid,
-      std::unique_ptr<Credentials> credentials,
-      const DataCallback& encrypted_credetials_callback,
-      const FailureCallback& failure_callback) = 0;
-
   // Verifies that data provided in |credentials| authenticates a cast device.
   // If the device is verified as a cast device, it returns |data| encrypted
   // with a public key derived from |credentials|.

extensions/browser/api/networking_private/networking_private_api.cc

@@ -725,55 +725,6 @@ void NetworkingPrivateVerifyDestinationFunction::Failure(
   Respond(Error(error));
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// NetworkingPrivateVerifyAndEncryptCredentialsFunction
-
-NetworkingPrivateVerifyAndEncryptCredentialsFunction::
-    ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {
-}
-
-ExtensionFunction::ResponseAction
-NetworkingPrivateVerifyAndEncryptCredentialsFunction::Run() {
-  // This method is private - as such, it should not be exposed through public
-  // networking.onc API.
-  // TODO(tbarzic): Consider exposing this via separate API.
-  // http://crbug.com/678737
-  if (!HasPrivateNetworkingAccess(extension(), source_context_type(),
-                                  source_url())) {
-    return RespondNow(Error(kPrivateOnlyError));
-  }
-  std::unique_ptr<private_api::VerifyAndEncryptCredentials::Params> params =
-      private_api::VerifyAndEncryptCredentials::Params::Create(*args_);
-  EXTENSION_FUNCTION_VALIDATE(params);
-
-  NetworkingCastPrivateDelegate* delegate =
-      ExtensionsAPIClient::Get()->GetNetworkingCastPrivateDelegate();
-  if (!delegate)
-    return RespondNow(Error("Not supported."));
-
-  delegate->VerifyAndEncryptCredentials(
-      params->network_guid, AsCastCredentials(params->properties),
-      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success,
-                 this),
-      base::Bind(&NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure,
-                 this));
-  // Success() or Failure() might have been called synchronously at this point.
-  // In that case this function has already called Respond(). Return
-  // AlreadyResponded() in that case.
-  return did_respond() ? AlreadyResponded() : RespondLater();
-}
-
-void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Success(
-    const std::string& result) {
-  Respond(ArgumentList(
-      private_api::VerifyAndEncryptCredentials::Results::Create(result)));
-}
-
-void NetworkingPrivateVerifyAndEncryptCredentialsFunction::Failure(
-    const std::string& error) {
-  Respond(Error(error));
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateVerifyAndEncryptDataFunction
 

extensions/browser/api/networking_private/networking_private_api.h

@@ -368,28 +368,6 @@ class NetworkingPrivateVerifyDestinationFunction
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateVerifyDestinationFunction);
 };
 
-// Implements the chrome.networkingPrivate.verifyAndEncryptCredentials method.
-class NetworkingPrivateVerifyAndEncryptCredentialsFunction
-    : public UIThreadExtensionFunction {
- public:
-  NetworkingPrivateVerifyAndEncryptCredentialsFunction() {}
-  DECLARE_EXTENSION_FUNCTION("networkingPrivate.verifyAndEncryptCredentials",
-                             NETWORKINGPRIVATE_VERIFYANDENCRYPTCREDENTIALS);
-
- protected:
-  ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() override;
-
-  // ExtensionFunction:
-  ResponseAction Run() override;
-
-  void Success(const std::string& result);
-  void Failure(const std::string& error);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(
-      NetworkingPrivateVerifyAndEncryptCredentialsFunction);
-};
-
 // Implements the chrome.networkingPrivate.verifyAndEncryptData method.
 class NetworkingPrivateVerifyAndEncryptDataFunction
     : public UIThreadExtensionFunction {

extensions/browser/api/networking_private/networking_private_stubs.cc

@@ -198,17 +198,6 @@ NetworkingPrivateVerifyDestinationFunction::Run() {
   return RespondNow(Error(kStubError));
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// NetworkingPrivateVerifyAndEncryptCredentialsFunction
-
-NetworkingPrivateVerifyAndEncryptCredentialsFunction::
-    ~NetworkingPrivateVerifyAndEncryptCredentialsFunction() {}
-
-ExtensionFunction::ResponseAction
-NetworkingPrivateVerifyAndEncryptCredentialsFunction::Run() {
-  return RespondNow(Error(kStubError));
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkingPrivateVerifyAndEncryptDataFunction
 

extensions/common/api/networking_private.idl

@@ -1072,18 +1072,6 @@ namespace networkingPrivate {
     static void verifyDestination(VerificationProperties properties,
                                   BooleanCallback callback);
 
-    // Verifies that the device is a trusted device and retrieves encrypted
-    // network credentials.
-    // |properties|: Properties of the destination to use in verifying that it
-    //     is a trusted device.
-    // |networkGuid|: The GUID of the Cellular network to activate.
-    // |callback|: A callback function that receives base64-encoded encrypted
-    //     credential data to send to a trusted device.
-    [nodoc, deprecated = "Use networking.castPrivate API."]
-    static void verifyAndEncryptCredentials(VerificationProperties properties,
-                                            DOMString networkGuid,
-                                            StringCallback callback);
-
     // Verifies that the device is a trusted device and encrypts supplied
     // data with device public key.
     // |properties|: Properties of the destination to use in verifying that it