Removed the PolicyDefinitionList.

chrome/browser/chromeos/policy/cloud_external_data_manager_base.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 "chrome/browser/chromeos/policy/cloud_external_data_manager_base.h"
 
 #include <map>
 #include <string>
 #include <vector>
 

[bartfab (slow), 2013/11/05 18:18:33]

Nit: policy/policy_constants.h now implicitly pulls in "callback_forward.h", so
all implementation files using it must #include "base/callback.h"

[Joao da Silva, 2013/11/07 20:27:27]

Done.

 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/cloud_external_data_store.h"
 #include "chrome/browser/policy/cloud/cloud_policy_store.h"
 #include "chrome/browser/policy/cloud/external_policy_data_fetcher.h"
 #include "chrome/browser/policy/cloud/external_policy_data_updater.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "net/url_request/url_request_context_getter.h"
-#include "policy/policy_constants.h"
 
 namespace policy {
 
 namespace {
 
 // Fetch data for at most two external data references at the same time.
 const int kMaxParallelFetches = 2;
 
 // Allows policies to reference |max_external_data_size_for_testing| bytes of
 // external data even if no |max_size| was specified in policy_templates.json.
 int max_external_data_size_for_testing = 0;
 
 }  // namespace
 
 // Backend for the CloudExternalDataManagerBase that handles all data download,
 // verification, caching and retrieval.
 class CloudExternalDataManagerBase::Backend {
  public:
-  // The |policy_definitions| are used to determine the maximum size that the
+  // |get_policy_details| is used to determine the maximum size that the
   // data referenced by each policy can have. This class can be instantiated on
   // any thread but from then on, may be accessed via the |task_runner_| only.
   // All FetchCallbacks will be invoked via |callback_task_runner|.
-  Backend(const PolicyDefinitionList* policy_definitions,
+  Backend(const GetChromePolicyDetailsCallback& get_policy_details,
           scoped_refptr<base::SequencedTaskRunner> task_runner,
           scoped_refptr<base::SequencedTaskRunner> callback_task_runner);
 
   // Allows downloaded external data to be cached in |external_data_store|.
   // Ownership of the store is taken. The store can be destroyed by calling
   // SetExternalDataStore(scoped_ptr<CloudExternalDataStore>()).
   void SetExternalDataStore(
       scoped_ptr<CloudExternalDataStore> external_data_store);
 
   // Allows downloading of external data via the |external_policy_data_fetcher|.
@@ skipping 34 matching lines @@
   void FetchAll();
 
  private:
   // List of callbacks to invoke when the attempt to retrieve external data
   // referenced by a policy completes successfully or fails permanently.
   typedef std::vector<ExternalDataFetcher::FetchCallback> FetchCallbackList;
 
   // Map from policy names to the lists of callbacks defined above.
   typedef std::map<std::string, FetchCallbackList> FetchCallbackMap;
 
-  // Looks up the maximum size that the data referenced by |policy| can have in
-  // |policy_definitions_|.
+  // Looks up the maximum size that the data referenced by |policy| can have.
   size_t GetMaxExternalDataSize(const std::string& policy) const;
 
   // Invokes |callback| via the |callback_task_runner_|, passing |data| as a
   // parameter.
   void RunCallback(const ExternalDataFetcher::FetchCallback& callback,
                    scoped_ptr<std::string> data) const;
 
   // Tells the |updater_| to download the external data referenced by |policy|.
   // If Connect() was not called yet and no |updater_| exists, does nothing.
   void StartDownload(const std::string& policy);
 
   // Used to determine the maximum size that the data referenced by each policy
   // can have.
-  const PolicyDefinitionList* policy_definitions_;
+  GetChromePolicyDetailsCallback get_policy_details_;
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   scoped_refptr<base::SequencedTaskRunner> callback_task_runner_;
 
   // Contains the policies for which a download of the referenced external data
   // has been requested. Each policy is mapped to a list of callbacks to invoke
   // when the download completes successfully or fails permanently. If no
   // callback needs to be invoked (because the download was requested via
   // FetchAll()), a map entry will still exist but the list of callbacks it maps
   // to will be empty.
@@ skipping 10 matching lines @@
   // Used to cache external data referenced by policies.
   scoped_ptr<CloudExternalDataStore> external_data_store_;
 
   // Used to download external data referenced by policies.
   scoped_ptr<ExternalPolicyDataUpdater> updater_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
 CloudExternalDataManagerBase::Backend::Backend(
-    const PolicyDefinitionList* policy_definitions,
+    const GetChromePolicyDetailsCallback& get_policy_details,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner)
-    : policy_definitions_(policy_definitions),
+    : get_policy_details_(get_policy_details),
       task_runner_(task_runner),
       callback_task_runner_(callback_task_runner),
       metadata_set_(false) {
 }
 
 void CloudExternalDataManagerBase::Backend::SetExternalDataStore(
     scoped_ptr<CloudExternalDataStore> external_data_store) {
   external_data_store_.reset(external_data_store.release());
   if (metadata_set_ && external_data_store_)
     external_data_store_->Prune(metadata_);
@@ skipping 130 matching lines @@
     StartDownload(policy);
   }
 }
 
 size_t CloudExternalDataManagerBase::Backend::GetMaxExternalDataSize(
     const std::string& policy) const {
   if (max_external_data_size_for_testing)
     return max_external_data_size_for_testing;
 
   // Look up the maximum size that the data referenced by |policy| can have in
-  // policy_definitions_, which is constructed from the information in
+  // get_policy_details, which is constructed from the information in
   // policy_templates.json, allowing the maximum data size to be specified as
   // part of the policy definition.
-  for (const PolicyDefinitionList::Entry* entry = policy_definitions_->begin;
-       entry != policy_definitions_->end; ++entry) {
-    if (entry->name == policy)
-      return entry->max_external_data_size;
-  }
+  const PolicyDetails* details = get_policy_details_.Run(policy);
+  if (details)
+    return details->max_external_data_size;
   NOTREACHED();
   return 0;
 }
 
 void CloudExternalDataManagerBase::Backend::RunCallback(
     const ExternalDataFetcher::FetchCallback& callback,
     scoped_ptr<std::string> data) const {
   callback_task_runner_->PostTask(FROM_HERE,
                                   base::Bind(callback, base::Passed(&data)));
 }
@@ skipping 10 matching lines @@
       ExternalPolicyDataUpdater::Request(metadata.url,
                                          metadata.hash,
                                          GetMaxExternalDataSize(policy)),
       base::Bind(&CloudExternalDataManagerBase::Backend::OnDownloadSuccess,
                  base::Unretained(this),
                  policy,
                  metadata.hash));
 }
 
 CloudExternalDataManagerBase::CloudExternalDataManagerBase(
-    const PolicyDefinitionList* policy_definitions,
+    const GetChromePolicyDetailsCallback& get_policy_details,
     scoped_refptr<base::SequencedTaskRunner> backend_task_runner,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner)
     : backend_task_runner_(backend_task_runner),
       io_task_runner_(io_task_runner),
-      backend_(new Backend(policy_definitions,
+      backend_(new Backend(get_policy_details,
                            backend_task_runner_,
                            base::MessageLoopProxy::current())) {
 }
 
 CloudExternalDataManagerBase::~CloudExternalDataManagerBase() {
   DCHECK(CalledOnValidThread());
   io_task_runner_->DeleteSoon(FROM_HERE,
                               external_policy_data_fetcher_backend_.release());
   backend_task_runner_->DeleteSoon(FROM_HERE, backend_.release());
 }
@@ skipping 85 matching lines @@
   max_external_data_size_for_testing = max_size;
 }
 
 void CloudExternalDataManagerBase::FetchAll() {
   DCHECK(CalledOnValidThread());
   backend_task_runner_->PostTask(FROM_HERE, base::Bind(
       &Backend::FetchAll, base::Unretained(backend_.get())));
 }
 
 }  // namespace policy