Implement fetching, caching and retrieval of external policy data

chrome/browser/policy/external_data_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_POLICY_EXTERNAL_DATA_MANAGER_H_
 #define CHROME_BROWSER_POLICY_EXTERNAL_DATA_MANAGER_H_
 
 #include <string>
 
 #include "chrome/browser/policy/external_data_fetcher.h"
 
 namespace policy {
 
 // Downloads, verifies, caches and retrieves external data referenced by
 // policies.
 // An implementation of this abstract interface should be provided for each
 // policy source (cloud policy, platform policy) that supports external data
 // references.
 class ExternalDataManager {
  public:
+  // Retrieves the external data referenced by |policy| and invokes |callback|
+  // with the result. If |policy| does not reference any external data, the
+  // |callback| is invoked with a NULL pointer. Otherwise, the |callback| is
+  // invoked with the referenced data once it has been successfully retrieved.
+  // If retrieval is temporarily impossible (e.g. no network connectivity), the
+  // |callback| will be invoked when the temporary hindrance is resolved. If
+  // retrieval is permanently impossible (e.g. |policy| references data that
+  // does not exist on the server), the |callback| will never be invoked.

[Joao da Silva, 2013/07/19 11:15:15]

Document what happens when Fetch is called multiple times for the same policy:

- does it fetch the external data twice?
- does it reuse previously fetched data?
- do all the callbacks get eventually called back?

[bartfab (slow), 2013/07/19 13:06:30]

I would not want to document this in ExternalDataManager as this is a generic
interface for which we may have platform-specific implementations in the future.
On some platforms, we may want to fetch the data every time it is requested
(e.g. Windows, if data is referenced via UNC paths), on others, we may want to
cache it (e.g. cloud policy, where data is referenced via URLs).

I added a comment to CloudExternalDataManagerBase, which is the cloud-specific
implementation with well-defined caching behavior.

   virtual void Fetch(const std::string& policy,
                      const ExternalDataFetcher::FetchCallback& callback) = 0;
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_EXTERNAL_DATA_MANAGER_H_