Refactored the ComponentCloudPolicyService.

chrome/browser/policy/cloud/component_cloud_policy_updater.cc

 // Copyright (c) 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 "chrome/browser/policy/cloud/component_cloud_policy_updater.h"
 
-#include <string>
-
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/policy/cloud/component_cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/external_policy_data_fetcher.h"
 #include "chrome/browser/policy/proto/cloud/chrome_extension_policy.pb.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
-#include "components/policy/core/common/policy_namespace.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // The maximum size of the serialized policy protobuf.
 const size_t kPolicyProtoMaxSize = 16 * 1024;
 
@@ skipping 31 matching lines @@
   // Validate the policy before doing anything else.
   PolicyNamespace ns;
   em::ExternalPolicyData data;
   if (!store_->ValidatePolicy(response.Pass(), &ns, &data)) {
     LOG(ERROR) << "Failed to validate component policy fetched from DMServer";
     return;
   }
 
   // Maybe the data for this hash has already been downloaded and cached.
   const std::string& cached_hash = store_->GetCachedHash(ns);
-  if (!cached_hash.empty() && data.secure_hash() == cached_hash) {
+  if (!cached_hash.empty() && data.secure_hash() == cached_hash)
     return;
-  }
 
   // TODO(joaodasilva): implement the other two auth methods.
   if (data.download_auth_method() != em::ExternalPolicyData::NONE)
     return;
 
-  // Encode |ns| into a string |key|.
-  const std::string domain = base::IntToString(ns.domain);
-  const std::string key =
-      base::IntToString(domain.size()) + ":" + domain + ":" + ns.component_id;
+  const std::string key = NamespaceToKey(ns);
 
   if (data.download_url().empty() || !data.has_secure_hash()) {
     // If there is no policy for this component or the policy has been removed,
     // cancel any existing request to fetch policy for this component.
     external_policy_data_updater_.CancelExternalDataFetch(key);
 
     // Delete any existing policy for this component.
     store_->Delete(ns);
   } else {
     // Make a request to fetch policy for this component. If another fetch
     // request is already pending for the component, it will be canceled.
     external_policy_data_updater_.FetchExternalData(
         key,
         ExternalPolicyDataUpdater::Request(data.download_url(),
                                            data.secure_hash(),
                                            kPolicyDataMaxSize),
         base::Bind(&ComponentCloudPolicyStore::Store, base::Unretained(store_),
                    ns,
                    serialized_response,
                    data.secure_hash()));
   }
 }
 
+void ComponentCloudPolicyUpdater::CancelUpdate(const PolicyNamespace& ns) {
+  external_policy_data_updater_.CancelExternalDataFetch(NamespaceToKey(ns));
+}
+
+std::string ComponentCloudPolicyUpdater::NamespaceToKey(
+    const PolicyNamespace& ns) {
+  const std::string domain = base::IntToString(ns.domain);
+  const std::string size = base::IntToString(domain.size());
+  return size + ":" + domain + ":" + ns.component_id;
+}
+
 }  // namespace policy