Drop verification_key_hash from CloudPolicyClient constructor

kPolicyVerificationKeyHash is the only possible value anyways (outside
of tests).

BUG=none

Review-Url: https://codereview.chromium.org/2537643003
Cr-Commit-Position: refs/heads/master@{#435006}

chrome/browser/chromeos/policy/device_cloud_policy_initializer.cc

@@ -264,8 +264,8 @@ std::unique_ptr<CloudPolicyClient> DeviceCloudPolicyInitializer::CreateClient(
                                             &machine_model);
   return base::MakeUnique<CloudPolicyClient>(
       statistics_provider_->GetEnterpriseMachineID(), machine_model,
-      kPolicyVerificationKeyHash, device_management_service,
-      g_browser_process->system_request_context(), signing_service_.get());
+      device_management_service, g_browser_process->system_request_context(),
+      signing_service_.get());
 }
 
 void DeviceCloudPolicyInitializer::TryToCreateClient() {

chrome/browser/chromeos/policy/device_local_account_policy_service.cc

@@ -13,6 +13,7 @@
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
@@ -65,10 +66,11 @@ std::unique_ptr<CloudPolicyClient> CreateClient(
     return std::unique_ptr<CloudPolicyClient>();
   }
 
-  std::unique_ptr<CloudPolicyClient> client(new CloudPolicyClient(
-      std::string(), std::string(), kPolicyVerificationKeyHash,
+  std::unique_ptr<CloudPolicyClient> client =
+      base::MakeUnique<CloudPolicyClient>(
+          std::string() /* machine_id */, std::string() /* machine_model */,
           device_management_service, system_request_context,
-      nullptr /* signing_service */));
+          nullptr /* signing_service */);
   client->SetupRegistration(policy_data->request_token(),
                             policy_data->device_id());
   return client;

chrome/browser/chromeos/policy/user_cloud_policy_manager_chromeos.cc

@@ -11,6 +11,7 @@
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sequenced_task_runner.h"
@@ -131,10 +132,11 @@ void UserCloudPolicyManagerChromeOS::Connect(
   // Use the system request context here instead of a context derived
   // from the Profile because Connect() is called before the profile is
   // fully initialized (required so we can perform the initial policy load).
-  std::unique_ptr<CloudPolicyClient> cloud_policy_client(new CloudPolicyClient(
-      std::string(), std::string(), kPolicyVerificationKeyHash,
+  std::unique_ptr<CloudPolicyClient> cloud_policy_client =
+      base::MakeUnique<CloudPolicyClient>(
+          std::string() /* machine_id */, std::string() /* machine_model */,
           device_management_service, system_request_context,
-      nullptr /* signing_service */));
+          nullptr /* signing_service */);
   CreateComponentCloudPolicyService(
       dm_protocol::kChromeExtensionPolicyType, component_policy_cache_path_,
       system_request_context, cloud_policy_client.get(), schema_registry());

components/policy/core/common/cloud/cloud_policy_client.cc

@@ -55,13 +55,11 @@ void CloudPolicyClient::Observer::OnRobotAuthCodesFetched(
 CloudPolicyClient::CloudPolicyClient(
     const std::string& machine_id,
     const std::string& machine_model,
-    const std::string& verification_key_hash,
     DeviceManagementService* service,
     scoped_refptr<net::URLRequestContextGetter> request_context,
     SigningService* signing_service)
     : machine_id_(machine_id),
       machine_model_(machine_model),
-      verification_key_hash_(verification_key_hash),
       service_(service),                  // Can be null for unit tests.
       signing_service_(signing_service),
       request_context_(request_context),
@@ -233,8 +231,7 @@ void CloudPolicyClient::FetchPolicy() {
     if (public_key_version_valid_)
       fetch_request->set_public_key_version(public_key_version_);
 
-    if (!verification_key_hash_.empty())
-      fetch_request->set_verification_key_hash(verification_key_hash_);
+    fetch_request->set_verification_key_hash(kPolicyVerificationKeyHash);
 
     // These fields are included only in requests for chrome policy.
     if (IsChromePolicy(type_to_fetch.first)) {

components/policy/core/common/cloud/cloud_policy_client.h

@@ -85,13 +85,10 @@ class POLICY_EXPORT CloudPolicyClient {
   // this is appropriate (i.e. device policy, but not user policy). |service|
   // and |signing_service| are weak pointers and it's the caller's
   // responsibility to keep them valid for the lifetime of CloudPolicyClient.
-  // |verification_key_hash| contains an identifier telling the DMServer which
-  // verification key to use. The |signing_service| is used to sign sensitive
-  // requests.
+  // The |signing_service| is used to sign sensitive requests.
   CloudPolicyClient(
       const std::string& machine_id,
       const std::string& machine_model,
-      const std::string& verification_key_hash,
       DeviceManagementService* service,
       scoped_refptr<net::URLRequestContextGetter> request_context,
       SigningService* signing_service);
@@ -377,7 +374,6 @@ class POLICY_EXPORT CloudPolicyClient {
   // Data necessary for constructing policy requests.
   const std::string machine_id_;
   const std::string machine_model_;
-  const std::string verification_key_hash_;
   PolicyTypeSet types_to_fetch_;
   std::vector<std::string> state_keys_to_upload_;
 

components/policy/core/common/cloud/cloud_policy_client_unittest.cc

@@ -191,11 +191,9 @@ class CloudPolicyClientTest : public testing::Test {
 
     request_context_ =
         new net::TestURLRequestContextGetter(loop_.task_runner());
-    client_.reset(new CloudPolicyClient(kMachineID, kMachineModel,
-                                        kPolicyVerificationKeyHash,
-                                        &service_,
-                                        request_context_,
-                                        &fake_signing_service_));
+    client_ = base::MakeUnique<CloudPolicyClient>(kMachineID, kMachineModel,
+                                                  &service_, request_context_,
+                                                  &fake_signing_service_);
     client_->AddPolicyTypeToFetch(policy_type_, std::string());
     client_->AddObserver(&observer_);
   }

components/policy/core/common/cloud/mock_cloud_policy_client.cc

@@ -14,12 +14,11 @@ namespace em = enterprise_management;
 namespace policy {
 
 MockCloudPolicyClient::MockCloudPolicyClient()
-    : CloudPolicyClient(std::string(),
-                        std::string(),
-                        std::string(),
-                        nullptr,
-                        nullptr,
-                        nullptr) {}
+    : CloudPolicyClient(std::string(), /* machine_id */
+                        std::string(), /* machine_model */
+                        nullptr,       /* service */
+                        nullptr,       /* request_context */
+                        nullptr /* signing_service */) {}
 
 MockCloudPolicyClient::~MockCloudPolicyClient() {}
 

components/policy/core/common/cloud/user_cloud_policy_manager.cc

@@ -73,9 +73,9 @@ UserCloudPolicyManager::CreateCloudPolicyClient(
     DeviceManagementService* device_management_service,
     scoped_refptr<net::URLRequestContextGetter> request_context) {
   return base::MakeUnique<CloudPolicyClient>(
-      std::string(), std::string(), kPolicyVerificationKeyHash,
+      std::string() /* machine_id */, std::string() /* machine_model */,
       device_management_service, request_context,
-      nullptr /* signing_service_ */);
+      nullptr /* signing_service */);
 }
 
 void UserCloudPolicyManager::DisconnectAndRemovePolicy() {

components/policy/core/common/remote_commands/remote_commands_service_unittest.cc

@@ -84,9 +84,8 @@ class TestingCloudPolicyClientForRemoteCommands : public CloudPolicyClient {
       TestingRemoteCommandsServer* server)
       : CloudPolicyClient(std::string(), /* machine_id */
                           std::string(), /* machine_model */
-                          std::string(), /* verification_key_hash */
-                          nullptr,
-                          nullptr,
+                          nullptr,       /* service */
+                          nullptr,       /* request_context */
                           nullptr /* signing_service */),
         server_(server) {
     dm_token_ = kDMToken;