Move NetworkingPrivateDelegate::CryptoVerify to networking_cast_private

chrome/browser/extensions/api/networking_private/networking_private_apitest.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 <stddef.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
+#include "chrome/browser/extensions/api/networking_cast_private/chrome_networking_cast_private_delegate.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/api/networking_private/networking_private_delegate.h"
 #include "extensions/browser/api/networking_private/networking_private_delegate_factory.h"
 #include "extensions/common/switches.h"
 
 namespace extensions {
 
 // This tests just the interface for the networkingPrivate API, i.e. it ensures
 // that the delegate methods are called as expected.
 
 // The implementations (which differ significantly between chromeos and
 // windows/mac) are tested independently in
 // networking_private_[chromeos|service_client]_apitest.cc.
 // See also crbug.com/460119.
 
 namespace {
 
 const char kFailure[] = "Failure";
 const char kSuccess[] = "Success";
 const char kGuid[] = "SOME_GUID";
 
-class TestDelegate : public NetworkingPrivateDelegate {
+class TestNetworkingPrivateDelegate : public NetworkingPrivateDelegate {
  public:
-  explicit TestDelegate(std::unique_ptr<VerifyDelegate> verify_delegate)
-      : NetworkingPrivateDelegate(std::move(verify_delegate)), fail_(false) {}
+  explicit TestNetworkingPrivateDelegate(bool test_failure)
+      : fail_(test_failure) {}
 
-  ~TestDelegate() override {}
+  ~TestNetworkingPrivateDelegate() override {}
 
   // Asynchronous methods
   void GetProperties(const std::string& guid,
                      const DictionaryCallback& success_callback,
                      const FailureCallback& failure_callback) override {
     DictionaryResult(guid, success_callback, failure_callback);
   }
 
   void GetManagedProperties(const std::string& guid,
                             const DictionaryCallback& success_callback,
@@ skipping 191 matching lines @@
       success_callback.Run();
     }
   }
 
  private:
   bool fail_;
   std::map<std::string, bool> enabled_;
   std::map<std::string, bool> disabled_;
   std::vector<bool> scan_requested_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestDelegate);
+  DISALLOW_COPY_AND_ASSIGN(TestNetworkingPrivateDelegate);
 };
 
-class TestVerifyDelegate : public NetworkingPrivateDelegate::VerifyDelegate {
+class TestNetworkingCastPrivateDelegate
+    : public ChromeNetworkingCastPrivateDelegate {
  public:
-  TestVerifyDelegate() : owner_(NULL) {}
+  explicit TestNetworkingCastPrivateDelegate(bool test_failure)
+      : fail_(test_failure) {}
 
-  ~TestVerifyDelegate() override {}
+  ~TestNetworkingCastPrivateDelegate() override {}
 
-  void VerifyDestination(
-      const VerificationProperties& verification_properties,
-      const BoolCallback& success_callback,
-      const FailureCallback& failure_callback) override {
-    owner_->BoolResult(success_callback, failure_callback);
+  void VerifyDestination(std::unique_ptr<Credentials> credentials,
+                         const VerifiedCallback& success_callback,
+                         const FailureCallback& failure_callback) override {
+    if (fail_) {
+      failure_callback.Run(kFailure);
+    } else {
+      success_callback.Run(true);
+    }
   }
+
   void VerifyAndEncryptCredentials(
       const std::string& guid,
-      const VerificationProperties& verification_properties,
-      const StringCallback& success_callback,
+      std::unique_ptr<Credentials> credentials,
+      const DataCallback& success_callback,
       const FailureCallback& failure_callback) override {
-    owner_->StringResult(success_callback, failure_callback);
+    if (fail_) {
+      failure_callback.Run(kFailure);
+    } else {
+      success_callback.Run("encrypted_credentials");
+    }
   }
-  void VerifyAndEncryptData(
-      const VerificationProperties& verification_properties,
-      const std::string& data,
-      const StringCallback& success_callback,
-      const FailureCallback& failure_callback) override {
-    owner_->StringResult(success_callback, failure_callback);
+  void VerifyAndEncryptData(const std::string& data,
+                            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_data");
+    }
   }
 
-  void set_owner(TestDelegate* owner) { owner_ = owner; }
+ private:
+  bool fail_;
 
- private:
-  TestDelegate* owner_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestVerifyDelegate);
+  DISALLOW_COPY_AND_ASSIGN(TestNetworkingCastPrivateDelegate);
 };
 
 class NetworkingPrivateApiTest : public ExtensionApiTest {
  public:
-  NetworkingPrivateApiTest() {
-    if (!s_test_delegate_) {
-      TestVerifyDelegate* verify_delegate = new TestVerifyDelegate;
-      std::unique_ptr<NetworkingPrivateDelegate::VerifyDelegate>
-          verify_delegate_ptr(verify_delegate);
-      s_test_delegate_ = new TestDelegate(std::move(verify_delegate_ptr));
-      verify_delegate->set_owner(s_test_delegate_);
-    }
-  }
+  using TestNetworkingPrivateDelegateFactory =
+      base::Callback<std::unique_ptr<KeyedService>()>;
 
   static std::unique_ptr<KeyedService> GetNetworkingPrivateDelegate(
       content::BrowserContext* profile) {
-    CHECK(s_test_delegate_);
-    return base::WrapUnique(s_test_delegate_);
+    CHECK(s_networking_private_delegate_factory_ptr);
+    return s_networking_private_delegate_factory_ptr->Run();
+  }
+
+  NetworkingPrivateApiTest() = default;
+  ~NetworkingPrivateApiTest() override = default;
+
+  void SetUp() override {
+    networking_cast_delegate_factory_ = base::Bind(
+        &NetworkingPrivateApiTest::CreateTestNetworkingCastPrivateDelegate,
+        base::Unretained(this), test_failure_);
+    ChromeNetworkingCastPrivateDelegate::SetFactoryCallbackForTest(
+        &networking_cast_delegate_factory_);
+
+    networking_private_delegate_factory_ = base::Bind(
+        &NetworkingPrivateApiTest::CreateTestNetworkingPrivateDelegate,
+        base::Unretained(this), test_failure_);
+    s_networking_private_delegate_factory_ptr =
+        &networking_private_delegate_factory_;
+
+    ExtensionApiTest::SetUp();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     ExtensionApiTest::SetUpCommandLine(command_line);
     // Whitelist the extension ID of the test extension.
     command_line->AppendSwitchASCII(
         extensions::switches::kWhitelistedExtensionID,
         "epcifkihnkjgphfkloaaleeakhpmgdmn");
   }
 
   void SetUpOnMainThread() override {
     ExtensionApiTest::SetUpOnMainThread();
     NetworkingPrivateDelegateFactory::GetInstance()->SetTestingFactory(
         profile(), &NetworkingPrivateApiTest::GetNetworkingPrivateDelegate);
-    content::RunAllPendingInMessageLoop();
+  }
+
+  void TearDown() override {
+    ExtensionApiTest::TearDown();
+
+    s_networking_private_delegate_factory_ptr = nullptr;
+    ChromeNetworkingCastPrivateDelegate::SetFactoryCallbackForTest(nullptr);
+
+    networking_private_delegate_ = nullptr;
   }
 
   bool GetEnabled(const std::string& type) {
-    return s_test_delegate_->GetEnabled(type);
+    return networking_private_delegate_->GetEnabled(type);
   }
 
   bool GetDisabled(const std::string& type) {
-    return s_test_delegate_->GetDisabled(type);
+    return networking_private_delegate_->GetDisabled(type);
   }
 
   size_t GetScanRequested() {
-    return s_test_delegate_->GetScanRequested();
+    return networking_private_delegate_->GetScanRequested();
   }
 
  protected:
   bool RunNetworkingSubtest(const std::string& subtest) {
     return RunExtensionSubtest("networking_private",
                                "main.html?" + subtest,
                                kFlagEnableFileAccess | kFlagLoadAsComponent);
   }
 
-  // Static pointer to the TestDelegate so that it can be accessed in
-  // GetNetworkingPrivateDelegate() passed to SetTestingFactory().
-  static TestDelegate* s_test_delegate_;
+ private:
+  std::unique_ptr<ChromeNetworkingCastPrivateDelegate>
+  CreateTestNetworkingCastPrivateDelegate(bool test_failure) {
+    return base::MakeUnique<TestNetworkingCastPrivateDelegate>(test_failure);
+  }
+
+  std::unique_ptr<KeyedService> CreateTestNetworkingPrivateDelegate(
+      bool test_failure) {
+    CHECK(!networking_private_delegate_);
+    auto delegate =
+        base::MakeUnique<TestNetworkingPrivateDelegate>(test_failure);
+    networking_private_delegate_ = delegate.get();
+    return delegate;
+  }
+
+ protected:
+  bool test_failure_ = false;
+
+ private:
+  // Pointer to a networking private delegate created by the test factory
+  // callback.
+  TestNetworkingPrivateDelegate* networking_private_delegate_ = nullptr;
+
+  TestNetworkingPrivateDelegateFactory networking_private_delegate_factory_;
+  // Static pointer to |test_delegate_factory_|, so it can be used from
+  // |CreateNetwokringPrivateDelegate|.
+  static TestNetworkingPrivateDelegateFactory*
+      s_networking_private_delegate_factory_ptr;
+
+  ChromeNetworkingCastPrivateDelegate::FactoryCallback
+      networking_cast_delegate_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTest);
 };
 
-// static
-TestDelegate* NetworkingPrivateApiTest::s_test_delegate_ = NULL;
+NetworkingPrivateApiTest::TestNetworkingPrivateDelegateFactory*
+    NetworkingPrivateApiTest::s_networking_private_delegate_factory_ptr =
+        nullptr;
 
 }  // namespace
 
 // Place each subtest into a separate browser test so that the stub networking
 // library state is reset for each subtest run. This way they won't affect each
 // other. TODO(stevenjb): Use extensions::ApiUnitTest once moved to
 // src/extensions.
 
 // These fail on Windows due to crbug.com/177163. Note: we still have partial
 // coverage in NetworkingPrivateServiceClientApiTest. TODO(stevenjb): Enable
@@ skipping 101 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTest, GetGlobalPolicy) {
   EXPECT_TRUE(RunNetworkingSubtest("getGlobalPolicy")) << message_;
 }
 
 // Test failure case
 
 class NetworkingPrivateApiTestFail : public NetworkingPrivateApiTest {
  public:
-  NetworkingPrivateApiTestFail() { s_test_delegate_->set_fail(true); }
+  NetworkingPrivateApiTestFail() { test_failure_ = true; }
+
+  ~NetworkingPrivateApiTestFail() override = default;
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateApiTestFail);
 };
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetProperties) {
   EXPECT_FALSE(RunNetworkingSubtest("getProperties")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, GetManagedProperties) {
@@ skipping 79 matching lines @@
   EXPECT_FALSE(RunNetworkingSubtest("unlockCellularSim")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateApiTestFail, SetCellularSimState) {
   EXPECT_FALSE(RunNetworkingSubtest("setCellularSimState")) << message_;
 }
 
 #endif // defined(OS_WIN)
 
 }  // namespace extensions