Implement device-local account policy pushing

chrome/browser/chromeos/policy/device_local_account_policy_service.cc

 // Copyright (c) 2012 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/device_local_account_policy_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/time/default_clock.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_external_data_service.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_store.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chrome/browser/policy/cloud/cloud_policy_invalidator.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chromeos/chromeos_paths.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_refresh_scheduler.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
@@ skipping 72 matching lines @@
                          &cache_root_dir));
   const base::FilePath path = cache_root_dir.Append(
       GetCacheSubdirectoryForAccountID(account_id_to_delete));
   if (base::DirectoryExists(path))
     base::DeleteFile(path, true);
 }
 
 }  // namespace
 
 DeviceLocalAccountPolicyBroker::DeviceLocalAccountPolicyBroker(
+    AffiliatedInvalidationServiceProvider* invalidation_service_provider,
     const DeviceLocalAccount& account,
     const base::FilePath& component_policy_cache_path,
     scoped_ptr<DeviceLocalAccountPolicyStore> store,
     scoped_refptr<DeviceLocalAccountExternalDataManager> external_data_manager,
     const base::Closure& policy_update_callback,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
-    : account_id_(account.account_id),
+    : invalidation_service_provider_(invalidation_service_provider),
+      account_id_(account.account_id),
       user_id_(account.user_id),
       component_policy_cache_path_(component_policy_cache_path),
       store_(store.Pass()),
       extension_tracker_(account, store_.get(), &schema_registry_),
       external_data_manager_(external_data_manager),
       core_(dm_protocol::kChromePublicAccountPolicyType,
             store_->account_id(),
             store_.get(),
             task_runner),
-      policy_update_callback_(policy_update_callback) {
+      policy_update_callback_(policy_update_callback),
+      highest_handled_invalidation_version_(0),
+      invalidation_service_(nullptr) {
   base::FilePath cache_root_dir;
   CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                          &cache_root_dir));
   extension_loader_ = new chromeos::DeviceLocalAccountExternalPolicyLoader(
       store_.get(),
       cache_root_dir.Append(
           GetCacheSubdirectoryForAccountID(account.account_id)));
   store_->AddObserver(this);
 
   // Unblock the |schema_registry_| so that the |component_policy_service_|
   // starts using it.
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()),
       g_browser_process->browser_policy_connector()->GetChromeSchema());
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
+
+  invalidation_service_provider_->RegisterConsumer(this);
 }
 
 DeviceLocalAccountPolicyBroker::~DeviceLocalAccountPolicyBroker() {
+  DestroyInvalidator();
+  invalidation_service_provider_->UnregisterConsumer(this);
   store_->RemoveObserver(this);
   external_data_manager_->SetPolicyStore(nullptr);
   external_data_manager_->Disconnect();
 }
 
 void DeviceLocalAccountPolicyBroker::Initialize() {
   store_->Load();
 }
 
 void DeviceLocalAccountPolicyBroker::ConnectIfPossible(
     chromeos::DeviceSettingsService* device_settings_service,
     DeviceManagementService* device_management_service,
     scoped_refptr<net::URLRequestContextGetter> request_context) {
-  if (core_.client())
+  if (IsConnected())
     return;
 
   scoped_ptr<CloudPolicyClient> client(CreateClient(device_settings_service,
                                                     device_management_service,
                                                     request_context));
   if (!client)
     return;
 
   CreateComponentCloudPolicyService(request_context, client.get());
   core_.Connect(client.Pass());
   external_data_manager_->Connect(request_context);
   core_.StartRefreshScheduler();
   UpdateRefreshDelay();
+  CreateInvalidatorIfPossible();
 }
 
 void DeviceLocalAccountPolicyBroker::UpdateRefreshDelay() {
   if (core_.refresh_scheduler()) {
     const base::Value* policy_value =
         store_->policy_map().GetValue(key::kPolicyRefreshRate);
     int delay = 0;
     if (policy_value && policy_value->GetAsInteger(&delay))
       core_.refresh_scheduler()->SetRefreshDelay(delay);
   }
@@ skipping 14 matching lines @@
 }
 
 void DeviceLocalAccountPolicyBroker::OnStoreError(CloudPolicyStore* store) {
   policy_update_callback_.Run();
 }
 
 void DeviceLocalAccountPolicyBroker::OnComponentCloudPolicyUpdated() {
   policy_update_callback_.Run();
 }
 
+void DeviceLocalAccountPolicyBroker::OnInvalidationServiceSet(
+    invalidation::InvalidationService* invalidation_service) {
+  DestroyInvalidator();
+
+  invalidation_service_ = invalidation_service;
+  if (invalidation_service_)
+    CreateInvalidatorIfPossible();
+}
+
+CloudPolicyInvalidator*
+DeviceLocalAccountPolicyBroker::GetInvalidatorForTest() const {
+  return invalidator_.get();
+}
+
+bool DeviceLocalAccountPolicyBroker::IsConnected() {
+  return core_.client();
+}
+
 void DeviceLocalAccountPolicyBroker::CreateComponentCloudPolicyService(
     const scoped_refptr<net::URLRequestContextGetter>& request_context,
     CloudPolicyClient* client) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableComponentCloudPolicy)) {
     // Disabled via the command line.
     return;
   }
 
   scoped_ptr<ResourceCache> resource_cache(
       new ResourceCache(component_policy_cache_path_,
                         content::BrowserThread::GetMessageLoopProxyForThread(
                             content::BrowserThread::FILE)));
 
   component_policy_service_.reset(new ComponentCloudPolicyService(
       this,
       &schema_registry_,
       core(),
       client,
       resource_cache.Pass(),
       request_context,
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::FILE),
       content::BrowserThread::GetMessageLoopProxyForThread(
           content::BrowserThread::IO)));
 }
 
+void DeviceLocalAccountPolicyBroker::CreateInvalidatorIfPossible() {
+  DCHECK(!invalidator_);
+
+  if (!invalidation_service_ || !IsConnected())
+    return;
+
+  invalidator_.reset(new CloudPolicyInvalidator(
+      enterprise_management::DeviceRegisterRequest::USER,
+      core(),
+      base::ThreadTaskRunnerHandle::Get(),
+      make_scoped_ptr(new base::DefaultClock),
+      highest_handled_invalidation_version_));
+  invalidator_->Initialize(invalidation_service_);
+}
+
+void DeviceLocalAccountPolicyBroker::DestroyInvalidator() {
+  if (!invalidator_)
+    return;
+
+  highest_handled_invalidation_version_ =
+      invalidator_->highest_handled_invalidation_version();
+  invalidator_->Shutdown();
+  invalidator_.reset();
+}
+
 DeviceLocalAccountPolicyService::DeviceLocalAccountPolicyService(
     chromeos::SessionManagerClient* session_manager_client,
     chromeos::DeviceSettingsService* device_settings_service,
     chromeos::CrosSettings* cros_settings,
+    AffiliatedInvalidationServiceProvider* invalidation_service_provider,
     scoped_refptr<base::SequencedTaskRunner> store_background_task_runner,
     scoped_refptr<base::SequencedTaskRunner> extension_cache_task_runner,
     scoped_refptr<base::SequencedTaskRunner>
         external_data_service_backend_task_runner,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner,
     scoped_refptr<net::URLRequestContextGetter> request_context)
     : session_manager_client_(session_manager_client),
       device_settings_service_(device_settings_service),
       cros_settings_(cros_settings),
+      invalidation_service_provider_(invalidation_service_provider),
       device_management_service_(nullptr),
       waiting_for_cros_settings_(false),
       orphan_extension_cache_deletion_state_(NOT_STARTED),
       store_background_task_runner_(store_background_task_runner),
       extension_cache_task_runner_(extension_cache_task_runner),
       request_context_(request_context),
       local_accounts_subscription_(cros_settings_->AddSettingsObserver(
           chromeos::kAccountsPrefDeviceLocalAccounts,
           base::Bind(&DeviceLocalAccountPolicyService::
                          UpdateAccountListIfNonePending,
@@ skipping 182 matching lines @@
       scoped_ptr<DeviceLocalAccountPolicyStore> store(
           new DeviceLocalAccountPolicyStore(it->account_id,
                                             session_manager_client_,
                                             device_settings_service_,
                                             store_background_task_runner_));
       scoped_refptr<DeviceLocalAccountExternalDataManager>
           external_data_manager =
               external_data_service_->GetExternalDataManager(it->account_id,
                                                              store.get());
       broker.reset(new DeviceLocalAccountPolicyBroker(
+          invalidation_service_provider_,
           *it,
           component_policy_cache_root_.Append(
               GetCacheSubdirectoryForAccountID(it->account_id)),
           store.Pass(),
           external_data_manager,
           base::Bind(&DeviceLocalAccountPolicyService::NotifyPolicyUpdated,
                      base::Unretained(this),
                      it->user_id),
           base::MessageLoopProxy::current()));
     }
@@ skipping 93 matching lines @@
   }
   return nullptr;
 }
 
 void DeviceLocalAccountPolicyService::NotifyPolicyUpdated(
     const std::string& user_id) {
   FOR_EACH_OBSERVER(Observer, observers_, OnPolicyUpdated(user_id));
 }
 
 }  // namespace policy