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 |