Introduce networkingPrivate.getCertificateLists

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

 // Copyright 2013 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 <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 10 matching lines @@
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
+#include "chromeos/network/network_certificate_handler.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "components/onc/onc_constants.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "components/policy/policy_constants.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_names.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/api/networking_private/networking_private_chromeos.h"
 #include "extensions/browser/api/networking_private/networking_private_delegate_factory.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/switches.h"
+#include "net/test/cert_test_util.h"
+#include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 // This tests the Chrome OS implementation of the networkingPrivate API
 // (NetworkingPrivateChromeOS). Note: The test expectations for chromeos, and
 // win/mac (NetworkingPrivateServiceClient) are different to reflect the
 // different implementations, but should be kept similar where possible.
 
 using testing::Return;
 using testing::_;
@@ skipping 69 matching lines @@
     ASSERT_EQ("00:01:02:03:04:05", credentials.device_bssid());
     ASSERT_EQ("c2lnbmVkX2RhdGE=", credentials.signed_data());
     ASSERT_EQ(
         "Device 0123,device_serial,00:01:02:03:04:05,cHVibGljX2tleQ==,nonce",
         credentials.unsigned_data());
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestNetworkingCastPrivateDelegate);
 };
 
+// This is testing NetworkingPrivateChromeOS, so only use overrides here to
+// provide extra functionality or bookkeeping for code paths that are otherwise
+// difficult to replicate in a test environment.
+class NetworkingPrivateChromeOSTestDelegate : public NetworkingPrivateChromeOS {
+ public:
+  explicit NetworkingPrivateChromeOSTestDelegate(
+      content::BrowserContext* context)
+      : NetworkingPrivateChromeOS(context) {}
+  ~NetworkingPrivateChromeOSTestDelegate() override {}
+
+  // NetworkingPrivateChromeOS
+  std::unique_ptr<base::DictionaryValue> GetCertificateLists() override {
+    // Send a certificates changed notification for testing the event.
+    chromeos::NetworkHandler::Get()
+        ->network_certificate_handler()
+        ->NotifyCertificatsChangedForTest();
+    return NetworkingPrivateChromeOS::GetCertificateLists();
+  }
+

[tbarzic, 2017/05/23 18:01:58]

private:

[stevenjb, 2017/05/25 00:01:11]

Done.

+  DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateChromeOSTestDelegate);
+};
+
 class UIDelegateStub : public NetworkingPrivateDelegate::UIDelegate {
  public:
   static int s_show_account_details_called_;
 
  private:
   // UIDelegate
   void ShowAccountDetails(const std::string& guid) const override {
     ++s_show_account_details_called_;
   }
   bool HandleConnectFailed(const std::string& guid,
@@ skipping 163 matching lines @@
   }
 
   void AddService(const std::string& service_path,
                   const std::string& name,
                   const std::string& type,
                   const std::string& state) {
     service_test_->AddService(service_path, service_path + "_guid", name, type,
                               state, true /* add_to_visible */);
   }
 
-  static std::unique_ptr<KeyedService> CreateNetworkingPrivateServiceClient(
+  static std::unique_ptr<KeyedService> CreateNetworkingPrivateDelegate(
       content::BrowserContext* context) {
     std::unique_ptr<NetworkingPrivateDelegate> result(
-        new NetworkingPrivateChromeOS(context));
+        new NetworkingPrivateChromeOSTestDelegate(context));
     std::unique_ptr<NetworkingPrivateDelegate::UIDelegate> ui_delegate(
         new UIDelegateStub);
     result->set_ui_delegate(std::move(ui_delegate));
     return result;
   }
 
   void SetUp() override {
     networking_cast_delegate_factory_ = base::Bind(
         &NetworkingPrivateChromeOSApiTest::CreateNetworkingCastPrivateDelegate,
         base::Unretained(this));
     ChromeNetworkingCastPrivateDelegate::SetFactoryCallbackForTest(
         &networking_cast_delegate_factory_);
 
     ExtensionApiTest::SetUp();
   }
 
   void SetUpOnMainThread() override {
     detector_ = new NetworkPortalDetectorTestImpl();
     chromeos::network_portal_detector::InitializeForTesting(detector_);
 
     ExtensionApiTest::SetUpOnMainThread();
     content::RunAllPendingInMessageLoop();
 
     NetworkingPrivateDelegateFactory::GetInstance()->SetTestingFactory(
-        profile(), &CreateNetworkingPrivateServiceClient);
+        profile(), &CreateNetworkingPrivateDelegate);
 
     InitializeSanitizedUsername();
 
     DBusThreadManager* dbus_manager = DBusThreadManager::Get();
     manager_test_ = dbus_manager->GetShillManagerClient()->GetTestInterface();
     profile_test_ = dbus_manager->GetShillProfileClient()->GetTestInterface();
     service_test_ = dbus_manager->GetShillServiceClient()->GetTestInterface();
     device_test_ = dbus_manager->GetShillDeviceClient()->GetTestInterface();
 
     ShillIPConfigClient::TestInterface* ip_config_test =
@@ skipping 114 matching lines @@
     profile_test_->AddService(kUser1ProfilePath, "stub_vpn2");
 
     content::RunAllPendingInMessageLoop();
   }
 
   void TearDown() override {
     ExtensionApiTest::TearDown();
     ChromeNetworkingCastPrivateDelegate::SetFactoryCallbackForTest(nullptr);
   }
 
- private:
   std::unique_ptr<ChromeNetworkingCastPrivateDelegate>
   CreateNetworkingCastPrivateDelegate() {
     return base::MakeUnique<TestNetworkingCastPrivateDelegate>();
   }
 
+  bool SetupCertificates() {
+    scoped_refptr<net::X509Certificate> system_ca_cert =
+        net::ImportCertFromFile(net::GetTestCertsDirectory(),
+                                "client_1_ca.pem");
+    if (!system_ca_cert)
+      return false;
+
+    net::CertificateList cert_list;
+    cert_list.push_back(std::move(system_ca_cert));
+    // TODO(stevenjb): Figure out a simple way to import a test user cert.
+
+    chromeos::NetworkHandler::Get()
+        ->network_certificate_handler()
+        ->SetCertificatesForTest(cert_list);
+    return true;
+  }
+
  protected:
   NetworkPortalDetectorTestImpl* detector() { return detector_; }
 
   NetworkPortalDetectorTestImpl* detector_;
   ShillManagerClient::TestInterface* manager_test_;
   ShillProfileClient::TestInterface* profile_test_;
   ShillServiceClient::TestInterface* service_test_;
   ShillDeviceClient::TestInterface* device_test_;
   policy::MockConfigurationPolicyProvider provider_;
   std::string userhash_;
@@ skipping 258 matching lines @@
                        OnNetworkListChangedEvent) {
   EXPECT_TRUE(RunNetworkingSubtest("onNetworkListChangedEvent")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        OnDeviceStateListChangedEvent) {
   EXPECT_TRUE(RunNetworkingSubtest("onDeviceStateListChangedEvent"))
       << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
+                       OnCertificateListsChangedEvent) {
+  EXPECT_TRUE(RunNetworkingSubtest("onCertificateListsChangedEvent"))
+      << message_;
+}
+
 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) {
@@ skipping 101 matching lines @@
   EXPECT_TRUE(RunNetworkingSubtest("getTetherNetworkManagedProperties"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        Tether_GetTetherNetworkState) {
   SetupTether();
   EXPECT_TRUE(RunNetworkingSubtest("getTetherNetworkState")) << message_;
 }
 
+IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetCertificateLists) {
+  ASSERT_TRUE(SetupCertificates());
+  EXPECT_TRUE(RunNetworkingSubtest("getCertificateLists")) << message_;
+}
+
 // Tests subset of networking API for the networking API alias - to verify that
 // using API methods and event does not cause access exceptions (due to
 // missing permissions).
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias) {
   SetupCellular();
   EXPECT_TRUE(RunPlatformAppTest("networking_private/alias")) << message_;
 }
 
 }  // namespace