Split up chrome/browser/policy subdirectory

chrome/browser/policy/component_cloud_policy_service.cc

Index: chrome/browser/policy/component_cloud_policy_service.cc
diff --git a/chrome/browser/policy/component_cloud_policy_service.cc b/chrome/browser/policy/component_cloud_policy_service.cc
deleted file mode 100644
index c8421e8583f54acd522a9ea471e806c3caec37f3..0000000000000000000000000000000000000000
--- a/chrome/browser/policy/component_cloud_policy_service.cc
+++ /dev/null
@@ -1,446 +0,0 @@
-// 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/component_cloud_policy_service.h"
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/location.h"
-#include "base/logging.h"
-#include "base/message_loop_proxy.h"
-#include "base/pickle.h"
-#include "base/sequenced_task_runner.h"
-#include "base/stl_util.h"
-#include "chrome/browser/policy/component_cloud_policy_store.h"
-#include "chrome/browser/policy/component_cloud_policy_updater.h"
-#include "chrome/browser/policy/proto/device_management_backend.pb.h"
-#include "chrome/browser/policy/resource_cache.h"
-#include "content/public/browser/browser_thread.h"
-#include "net/url_request/url_request_context_getter.h"
-
-namespace em = enterprise_management;
-
-namespace policy {
-
-const char ComponentCloudPolicyService::kComponentNamespaceCache[] =
-    "component-namespace-cache";
-
-ComponentCloudPolicyService::Delegate::~Delegate() {}
-
-// Owns the objects that live on the background thread, and posts back to UI
-// to the service whenever the policy changes.
-class ComponentCloudPolicyService::Backend
-    : public ComponentCloudPolicyStore::Delegate {
- public:
-  Backend(base::WeakPtr<ComponentCloudPolicyService> service,
-          scoped_refptr<base::SequencedTaskRunner> task_runner,
-          scoped_ptr<ResourceCache> cache);
-  ~Backend();
-
-  // This is invoked right after the constructor but on the backend background
-  // thread. Used to create the store on the right thread.
-  void Init();
-
-  // Reads the initial list of components and the initial policy.
-  void FinalizeInit();
-
-  // Creates the backend updater.
-  void Connect(scoped_refptr<net::URLRequestContextGetter> request_context);
-
-  // Stops updating remote data. Cached policies are still served.
-  void Disconnect();
-
-  // Loads the initial policies from the store. |username| and |dm_token| are
-  // used to validate the cached policies.
-  void SetCredentials(const std::string& username, const std::string& dm_token);
-
-  // Passes a policy protobuf to the backend, to start its validation and
-  // eventual download of the policy data on the background thread.
-  // This is ignored if the backend isn't connected.
-  void UpdateExternalPolicy(scoped_ptr<em::PolicyFetchResponse> response);
-
-  // ComponentCloudPolicyStore::Delegate implementation:
-  virtual void OnComponentCloudPolicyStoreUpdated() OVERRIDE;
-
-  // Passes the current list of components in |domain|, so that the disk cache
-  // can purge components that aren't being tracked anymore.
-  void SetCurrentComponents(PolicyDomain domain, const StringSet* components);
-
- private:
-  scoped_ptr<ComponentMap> ReadCachedComponents();
-
-  base::WeakPtr<ComponentCloudPolicyService> service_;
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
-  scoped_ptr<ResourceCache> cache_;
-  scoped_ptr<ComponentCloudPolicyStore> store_;
-  scoped_ptr<ComponentCloudPolicyUpdater> updater_;
-
-  DISALLOW_COPY_AND_ASSIGN(Backend);
-};
-
-ComponentCloudPolicyService::Backend::Backend(
-    base::WeakPtr<ComponentCloudPolicyService> service,
-    scoped_refptr<base::SequencedTaskRunner> task_runner,
-    scoped_ptr<ResourceCache> cache)
-    : service_(service),
-      task_runner_(task_runner),
-      cache_(cache.Pass()) {}
-
-ComponentCloudPolicyService::Backend::~Backend() {}
-
-void ComponentCloudPolicyService::Backend::Init() {
-  DCHECK(!store_);
-  store_.reset(new ComponentCloudPolicyStore(this, cache_.get()));
-}
-
-void ComponentCloudPolicyService::Backend::FinalizeInit() {
-  // Read the components that were cached in the last SetCurrentComponents()
-  // calls for each domain.
-  scoped_ptr<ComponentMap> components = ReadCachedComponents();
-
-  // Read the initial policy.
-  store_->Load();
-  scoped_ptr<PolicyBundle> policy(new PolicyBundle);
-  policy->CopyFrom(store_->policy());
-
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&ComponentCloudPolicyService::OnBackendInitialized,
-                 service_,
-                 base::Passed(&components),
-                 base::Passed(&policy)));
-}
-
-void ComponentCloudPolicyService::Backend::SetCredentials(
-    const std::string& username,
-    const std::string& dm_token) {
-  store_->SetCredentials(username, dm_token);
-}
-
-void ComponentCloudPolicyService::Backend::Connect(
-    scoped_refptr<net::URLRequestContextGetter> request_context) {
-  updater_.reset(new ComponentCloudPolicyUpdater(
-      task_runner_, request_context, store_.get()));
-}
-
-void ComponentCloudPolicyService::Backend::Disconnect() {
-  updater_.reset();
-}
-
-void ComponentCloudPolicyService::Backend::UpdateExternalPolicy(
-    scoped_ptr<em::PolicyFetchResponse> response) {
-  if (updater_)
-    updater_->UpdateExternalPolicy(response.Pass());
-}
-
-void ComponentCloudPolicyService::Backend::
-    OnComponentCloudPolicyStoreUpdated() {
-  scoped_ptr<PolicyBundle> bundle(new PolicyBundle);
-  bundle->CopyFrom(store_->policy());
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI, FROM_HERE,
-      base::Bind(&ComponentCloudPolicyService::OnPolicyUpdated,
-                 service_,
-                 base::Passed(&bundle)));
-}
-
-void ComponentCloudPolicyService::Backend::SetCurrentComponents(
-    PolicyDomain domain,
-    const StringSet* components) {
-  // Store the current list of components in the cache.
-  std::string policy_type;
-  if (ComponentCloudPolicyStore::GetPolicyType(domain, &policy_type)) {
-    Pickle pickle;
-    for (StringSet::const_iterator it = components->begin();
-         it != components->end(); ++it) {
-      pickle.WriteString(*it);
-    }
-    std::string data(reinterpret_cast<const char*>(pickle.data()),
-                     pickle.size());
-    cache_->Store(kComponentNamespaceCache, policy_type, data);
-  }
-
-  // Purge any components that have been removed.
-  if (store_)
-    store_->Purge(domain, *components);
-}
-
-scoped_ptr<ComponentCloudPolicyService::ComponentMap>
-    ComponentCloudPolicyService::Backend::ReadCachedComponents() {
-  scoped_ptr<ComponentMap> components(new ComponentMap);
-  std::map<std::string, std::string> contents;
-  cache_->LoadAllSubkeys(kComponentNamespaceCache, &contents);
-  for (std::map<std::string, std::string>::iterator it = contents.begin();
-       it != contents.end(); ++it) {
-    PolicyDomain domain;
-    if (ComponentCloudPolicyStore::GetPolicyDomain(it->first, &domain)) {
-      StringSet& set = (*components)[domain];
-      const Pickle pickle(it->second.data(), it->second.size());
-      PickleIterator pickit(pickle);
-      std::string id;
-      while (pickit.ReadString(&id))
-        set.insert(id);
-    } else {
-      cache_->Delete(kComponentNamespaceCache, it->first);
-    }
-  }
-  return components.Pass();
-}
-
-ComponentCloudPolicyService::ComponentCloudPolicyService(
-    Delegate* delegate,
-    CloudPolicyStore* store,
-    scoped_ptr<ResourceCache> cache)
-    : delegate_(delegate),
-      backend_(NULL),
-      client_(NULL),
-      store_(store),
-      is_initialized_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
-  store_->AddObserver(this);
-
-  // TODO(joaodasilva): this can't currently live on the blocking pool because
-  // creating URLFetchers requires a MessageLoop.
-  backend_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
-      content::BrowserThread::FILE);
-  backend_ = new Backend(weak_ptr_factory_.GetWeakPtr(),
-                         backend_task_runner_,
-                         cache.Pass());
-  backend_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Backend::Init, base::Unretained(backend_)));
-
-  if (store_->is_initialized())
-    InitializeBackend();
-}
-
-ComponentCloudPolicyService::~ComponentCloudPolicyService() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  store_->RemoveObserver(this);
-  if (client_)
-    client_->RemoveObserver(this);
-  backend_task_runner_->DeleteSoon(FROM_HERE, backend_);
-  backend_ = NULL;
-}
-
-// static
-bool ComponentCloudPolicyService::SupportsDomain(PolicyDomain domain) {
-  return ComponentCloudPolicyStore::SupportsDomain(domain);
-}
-
-void ComponentCloudPolicyService::Connect(
-    CloudPolicyClient* client,
-    scoped_refptr<net::URLRequestContextGetter> request_context) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK(!client_);
-  client_ = client;
-  client_->AddObserver(this);
-  // Create the updater in the backend.
-  backend_task_runner_->PostTask(FROM_HERE,
-                                 base::Bind(&Backend::Connect,
-                                            base::Unretained(backend_),
-                                            request_context));
-  if (is_initialized())
-    InitializeClient();
-}
-
-void ComponentCloudPolicyService::Disconnect() {
-  if (client_) {
-    // Unregister all the current components.
-    for (ComponentMap::iterator it = registered_components_.begin();
-         it != registered_components_.end(); ++it) {
-      RemoveNamespacesToFetch(it->first, it->second);
-    }
-
-    client_->RemoveObserver(this);
-    client_ = NULL;
-
-    backend_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&Backend::Disconnect, base::Unretained(backend_)));
-  }
-}
-
-void ComponentCloudPolicyService::RegisterPolicyDomain(
-    PolicyDomain domain,
-    const std::set<std::string>& current_ids) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  DCHECK(SupportsDomain(domain));
-
-  // Send the new set to the backend, to purge the cache.
-  backend_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&Backend::SetCurrentComponents,
-                 base::Unretained(backend_),
-                 domain,
-                 base::Owned(new StringSet(current_ids))));
-
-  // Register the current list of components for |domain| at the |client_|.
-  StringSet& registered_ids = registered_components_[domain];
-  if (client_ && is_initialized()) {
-    if (UpdateClientNamespaces(domain, registered_ids, current_ids))
-      delegate_->OnComponentCloudPolicyRefreshNeeded();
-  }
-  registered_ids = current_ids;
-}
-
-void ComponentCloudPolicyService::OnPolicyFetched(CloudPolicyClient* client) {
-  DCHECK_EQ(client_, client);
-  // Pass each PolicyFetchResponse whose policy type is registered to the
-  // Backend.
-  const CloudPolicyClient::ResponseMap& responses = client_->responses();
-  for (CloudPolicyClient::ResponseMap::const_iterator it = responses.begin();
-       it != responses.end(); ++it) {
-    const PolicyNamespaceKey& key(it->first);
-    PolicyDomain domain;
-    if (ComponentCloudPolicyStore::GetPolicyDomain(key.first, &domain) &&
-        ContainsKey(registered_components_[domain], key.second)) {
-      scoped_ptr<em::PolicyFetchResponse> response(
-          new em::PolicyFetchResponse(*it->second));
-      backend_task_runner_->PostTask(FROM_HERE,
-                                     base::Bind(&Backend::UpdateExternalPolicy,
-                                                base::Unretained(backend_),
-                                                base::Passed(&response)));
-    }
-  }
-}
-
-void ComponentCloudPolicyService::OnRegistrationStateChanged(
-    CloudPolicyClient* client) {
-  // Ignored.
-}
-
-void ComponentCloudPolicyService::OnClientError(CloudPolicyClient* client) {
-  // Ignored.
-}
-
-void ComponentCloudPolicyService::OnStoreLoaded(CloudPolicyStore* store) {
-  DCHECK_EQ(store_, store);
-  if (store_->is_initialized()) {
-    if (is_initialized()) {
-      // The backend is already initialized; update the credentials, in case
-      // a new dmtoken or server key became available.
-      SetCredentialsAndReloadClient();
-    } else {
-      // The |store_| just became ready; initialize the backend now.
-      InitializeBackend();
-    }
-  }
-}
-
-void ComponentCloudPolicyService::OnStoreError(CloudPolicyStore* store) {
-  OnStoreLoaded(store);
-}
-
-void ComponentCloudPolicyService::InitializeBackend() {
-  DCHECK(!is_initialized());
-  DCHECK(store_->is_initialized());
-
-  // Set the credentials for the initial policy load, if available.
-  SetCredentialsAndReloadClient();
-
-  backend_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&Backend::FinalizeInit, base::Unretained(backend_)));
-}
-
-void ComponentCloudPolicyService::OnBackendInitialized(
-    scoped_ptr<ComponentMap> cached_components,
-    scoped_ptr<PolicyBundle> initial_policy) {
-  // InitializeBackend() may be called multiple times if the |store_| fires
-  // events while the backend is loading.
-  if (is_initialized())
-    return;
-
-  // RegisterPolicyDomain() may have been called while the backend was
-  // initializing; only update |registered_components_| from |cached_components|
-  // for domains that haven't registered yet.
-  for (ComponentMap::iterator it = cached_components->begin();
-       it != cached_components->end(); ++it) {
-    // Lookup without inserting an empty set.
-    if (registered_components_.find(it->first) != registered_components_.end())
-      continue;  // Ignore the cached list if a more recent one was registered.
-    registered_components_[it->first].swap(it->second);
-  }
-
-  // A client may have already connected while the backend was initializing.
-  if (client_)
-    InitializeClient();
-
-  // Set the initial policy, and send the initial update callback.
-  is_initialized_ = true;
-  OnPolicyUpdated(initial_policy.Pass());
-}
-
-void ComponentCloudPolicyService::InitializeClient() {
-  // Register all the current components.
-  bool added = false;
-  for (ComponentMap::iterator it = registered_components_.begin();
-       it != registered_components_.end(); ++it) {
-    added |= !it->second.empty();
-    AddNamespacesToFetch(it->first, it->second);
-  }
-  // The client may already have PolicyFetchResponses for registered components;
-  // load them now.
-  OnPolicyFetched(client_);
-  if (added && is_initialized())
-    delegate_->OnComponentCloudPolicyRefreshNeeded();
-}
-
-void ComponentCloudPolicyService::OnPolicyUpdated(
-    scoped_ptr<PolicyBundle> policy) {
-  policy_.Swap(policy.get());
-  // Don't propagate updates until the initial store Load() has been done.
-  if (is_initialized())
-    delegate_->OnComponentCloudPolicyUpdated();
-}
-
-void ComponentCloudPolicyService::SetCredentialsAndReloadClient() {
-  const em::PolicyData* policy = store_->policy();
-  if (!policy || !policy->has_username() || !policy->has_request_token())
-    return;
-  backend_task_runner_->PostTask(FROM_HERE,
-                                 base::Bind(&Backend::SetCredentials,
-                                            base::Unretained(backend_),
-                                            policy->username(),
-                                            policy->request_token()));
-  // If this was the initial register, or if the signing key changed, then the
-  // previous OnPolicyFetched() call had its PolicyFetchResponses rejected
-  // because the credentials weren't updated yet. Reload all the responses in
-  // the client now to handle those cases; if those responses have already been
-  // validated then they will be ignored.
-  if (client_)
-    OnPolicyFetched(client_);
-}
-
-bool ComponentCloudPolicyService::UpdateClientNamespaces(
-    PolicyDomain domain,
-    const StringSet& old_set,
-    const StringSet& new_set) {
-  StringSet added = base::STLSetDifference<StringSet>(new_set, old_set);
-  StringSet removed = base::STLSetDifference<StringSet>(old_set, new_set);
-  AddNamespacesToFetch(domain, added);
-  RemoveNamespacesToFetch(domain, removed);
-  return !added.empty();
-}
-
-void ComponentCloudPolicyService::AddNamespacesToFetch(PolicyDomain domain,
-                                                       const StringSet& set) {
-  std::string policy_type;
-  if (ComponentCloudPolicyStore::GetPolicyType(domain, &policy_type)) {
-    for (StringSet::const_iterator it = set.begin(); it != set.end(); ++it)
-      client_->AddNamespaceToFetch(PolicyNamespaceKey(policy_type, *it));
-  }
-}
-
-void ComponentCloudPolicyService::RemoveNamespacesToFetch(
-    PolicyDomain domain,
-    const StringSet& set) {
-  std::string policy_type;
-  if (ComponentCloudPolicyStore::GetPolicyType(domain, &policy_type)) {
-    for (StringSet::const_iterator it = set.begin(); it != set.end(); ++it)
-      client_->RemoveNamespaceToFetch(PolicyNamespaceKey(policy_type, *it));
-  }
-}
-
-}  // namespace policy