New policy protobuf protocol.

chrome/browser/policy/device_management_policy_provider.cc

 // Copyright (c) 2011 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/device_management_policy_provider.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/rand_util.h"
 #include "base/task.h"
 #include "chrome/browser/browser_thread.h"
+#include "chrome/browser/policy/cloud_policy_cache.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_management_policy_cache.h"
 #include "chrome/browser/policy/profile_policy_context.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 
@@ skipping 10 matching lines @@
 
 // These are the base values for delays before retrying after an error. They
 // will be doubled each time they are used.
 const int64 kPolicyRefreshErrorDelayInMilliseconds = 3 * 1000;  // 3 seconds
 const int64 kDeviceTokenRefreshErrorDelayInMilliseconds = 3 * 1000;
 // For unmanaged devices, check once per day whether they're still unmanaged.
 const int64 kPolicyRefreshUnmanagedDeviceInMilliseconds = 24 * 60 * 60 * 1000;
 
 const FilePath::StringType kDeviceTokenFilename = FILE_PATH_LITERAL("Token");
 const FilePath::StringType kPolicyFilename = FILE_PATH_LITERAL("Policy");
+const FilePath::StringType kCloudPolicyFilename =
+    FILE_PATH_LITERAL("CloudPolicy");

[Mattias Nissler (ping if slow), 2011/02/02 12:27:55]

See my other comment about having only one cache.

[Jakob Kummerow, 2011/02/03 14:36:52]

Done.

 
 // Calls back into the provider to refresh policy.
 class DeviceManagementPolicyProvider::RefreshTask : public CancelableTask {
  public:
   explicit RefreshTask(DeviceManagementPolicyProvider* provider)
       : provider_(provider) {}
 
   // Task implementation:
   virtual void Run() {
     if (provider_)
       provider_->RefreshTaskExecute();
   }
 
   // CancelableTask implementation:
   virtual void Cancel() {
     provider_ = NULL;
   }
 
  private:
   DeviceManagementPolicyProvider* provider_;
 };
 
 DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
     const ConfigurationPolicyProvider::PolicyDefinitionList* policy_list,
     DeviceManagementBackend* backend,
-    Profile* profile)
+    Profile* profile,
+    bool cloud_policy_enabled)
     : ConfigurationPolicyProvider(policy_list) {
   Initialize(backend,
              profile,
+             cloud_policy_enabled,
              ProfilePolicyContext::kDefaultPolicyRefreshRateInMilliseconds,
              kPolicyRefreshDeviationFactorPercent,
              kPolicyRefreshDeviationMaxInMilliseconds,
              kPolicyRefreshErrorDelayInMilliseconds,
              kDeviceTokenRefreshErrorDelayInMilliseconds,
              kPolicyRefreshUnmanagedDeviceInMilliseconds);
 }
 
 DeviceManagementPolicyProvider::~DeviceManagementPolicyProvider() {
   FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                     observer_list_,
                     OnProviderGoingAway());
   CancelRefreshTask();
 }
 
 bool DeviceManagementPolicyProvider::Provide(
     ConfigurationPolicyStoreInterface* policy_store) {
-  scoped_ptr<DictionaryValue> policies(cache_->GetPolicy());
-  DecodePolicyValueTree(policies.get(), policy_store);
+  if (cloud_policy_enabled_) {
+    scoped_ptr<PolicyMapType> policies(cache2_->GetPolicy());
+    ApplyPolicyMap(policies.get(), policy_store);
+  } else {
+    scoped_ptr<DictionaryValue> policies(cache_->GetPolicy());
+    DecodePolicyValueTree(policies.get(), policy_store);
+  }
   return true;
 }
 
 bool DeviceManagementPolicyProvider::IsInitializationComplete() const {
-  return !cache_->last_policy_refresh_time().is_null();
+  if (cloud_policy_enabled_)
+    return !cache2_->last_policy_refresh_time().is_null();
+  else
+    return !cache_->last_policy_refresh_time().is_null();
 }
 
 void DeviceManagementPolicyProvider::HandlePolicyResponse(
     const em::DevicePolicyResponse& response) {
   DCHECK(TokenAvailable());
   if (cache_->SetPolicy(response)) {
     initial_fetch_done_ = true;
     NotifyCloudPolicyUpdate();
   }
   SetState(STATE_POLICY_VALID);
 }
 
+void DeviceManagementPolicyProvider::HandleCloudPolicyResponse(
+    const em::CloudPolicyResponse& response) {
+  DCHECK(TokenAvailable());
+  if (cache2_->SetPolicy(response)) {
+     initial_fetch_done_ = true;
+     NotifyCloudPolicyUpdate();
+  }
+  SetState(STATE_POLICY_VALID);
+}
+
 void DeviceManagementPolicyProvider::OnError(
     DeviceManagementBackend::ErrorCode code) {
   DCHECK(TokenAvailable());
   if (code == DeviceManagementBackend::kErrorServiceDeviceNotFound ||
       code == DeviceManagementBackend::kErrorServiceManagementTokenInvalid) {
     LOG(WARNING) << "The device token was either invalid or unknown to the "
                  << "device manager, re-registering device.";
     SetState(STATE_TOKEN_RESET);
   } else if (code ==
              DeviceManagementBackend::kErrorServiceManagementNotSupported) {
@@ skipping 15 matching lines @@
 
 void DeviceManagementPolicyProvider::OnTokenError() {
   DCHECK(!TokenAvailable());
   LOG(WARNING) << "Could not retrieve device token.";
   SetState(STATE_TOKEN_ERROR);
 }
 
 void DeviceManagementPolicyProvider::OnNotManaged() {
   DCHECK(!TokenAvailable());
   VLOG(1) << "This device is not managed.";
-  cache_->SetDeviceUnmanaged();
+  if (cloud_policy_enabled_)
+    cache2_->SetUnmanaged();
+  else
+    cache_->SetDeviceUnmanaged();
   SetState(STATE_UNMANAGED);
 }
 
 void DeviceManagementPolicyProvider::SetRefreshRate(
     int64 refresh_rate_milliseconds) {
   policy_refresh_rate_ms_ = refresh_rate_milliseconds;
 
   // Reschedule the refresh task if necessary.
   if (state_ == STATE_POLICY_VALID)
     SetState(STATE_POLICY_VALID);
 }
 
 DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
     const PolicyDefinitionList* policy_list,
     DeviceManagementBackend* backend,
     Profile* profile,
+    bool cloud_policy_enabled,
     int64 policy_refresh_rate_ms,
     int policy_refresh_deviation_factor_percent,
     int64 policy_refresh_deviation_max_ms,
     int64 policy_refresh_error_delay_ms,
     int64 token_fetch_error_delay_ms,
     int64 unmanaged_device_refresh_rate_ms)
     : ConfigurationPolicyProvider(policy_list) {
   Initialize(backend,
              profile,
+             cloud_policy_enabled,
              policy_refresh_rate_ms,
              policy_refresh_deviation_factor_percent,
              policy_refresh_deviation_max_ms,
              policy_refresh_error_delay_ms,
              token_fetch_error_delay_ms,
              unmanaged_device_refresh_rate_ms);
 }
 
 void DeviceManagementPolicyProvider::Initialize(
     DeviceManagementBackend* backend,
     Profile* profile,
+    bool cloud_policy_enabled,
     int64 policy_refresh_rate_ms,
     int policy_refresh_deviation_factor_percent,
     int64 policy_refresh_deviation_max_ms,
     int64 policy_refresh_error_delay_ms,
     int64 token_fetch_error_delay_ms,
     int64 unmanaged_device_refresh_rate_ms) {
   DCHECK(profile);
   backend_.reset(backend);
   profile_ = profile;
   storage_dir_ = GetOrCreateDeviceManagementDir(profile_->GetPath());
   state_ = STATE_INITIALIZING;
   initial_fetch_done_ = false;
   refresh_task_ = NULL;
   policy_refresh_rate_ms_ = policy_refresh_rate_ms;
   policy_refresh_deviation_factor_percent_ =
       policy_refresh_deviation_factor_percent;
   policy_refresh_deviation_max_ms_ = policy_refresh_deviation_max_ms;
   policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms;
   effective_policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms;
   token_fetch_error_delay_ms_ = token_fetch_error_delay_ms;
   effective_token_fetch_error_delay_ms_ = token_fetch_error_delay_ms;
   unmanaged_device_refresh_rate_ms_ = unmanaged_device_refresh_rate_ms;
 
-  const FilePath policy_path = storage_dir_.Append(kPolicyFilename);
-  cache_.reset(new DeviceManagementPolicyCache(policy_path));
-  cache_->LoadPolicyFromFile();
+  cloud_policy_enabled_ = cloud_policy_enabled;
+  if (cloud_policy_enabled_) {
+    const FilePath policy_path = storage_dir_.Append(kCloudPolicyFilename);
+    cache2_.reset(new CloudPolicyCache(policy_path));
+    cache2_->LoadPolicyFromFile();
+  } else {
+    const FilePath policy_path = storage_dir_.Append(kPolicyFilename);
+    cache_.reset(new DeviceManagementPolicyCache(policy_path));
+    cache_->LoadPolicyFromFile();
+  }
 
   SetDeviceTokenFetcher(new DeviceTokenFetcher(backend_.get(), profile,
                                                GetTokenPath()));
 
-  if (cache_->is_device_unmanaged()) {
+  if ((cloud_policy_enabled_ && cache2_->is_unmanaged()) ||
+      (!cloud_policy_enabled_ && cache_->is_device_unmanaged())) {
     // This is a non-first login on an unmanaged device.
     SetState(STATE_UNMANAGED);
   } else {
     SetState(STATE_INITIALIZING);
   }
 }
 
 void DeviceManagementPolicyProvider::AddObserver(
     ConfigurationPolicyProvider::Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void DeviceManagementPolicyProvider::RemoveObserver(
     ConfigurationPolicyProvider::Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void DeviceManagementPolicyProvider::SendPolicyRequest() {
-  em::DevicePolicyRequest policy_request;
-  policy_request.set_policy_scope(kChromePolicyScope);
-  em::DevicePolicySettingRequest* setting =
-      policy_request.add_setting_request();
-  setting->set_key(kChromeDevicePolicySettingKey);
-  setting->set_watermark("");
-  backend_->ProcessPolicyRequest(token_fetcher_->GetDeviceToken(),
-                                 token_fetcher_->GetDeviceID(),
-                                 policy_request, this);
+  if (cloud_policy_enabled_) {
+    em::CloudPolicyRequest policy_request;
+    policy_request.set_policy_scope(kChromePolicyScope);
+    backend_->ProcessCloudPolicyRequest(token_fetcher_->GetDeviceToken(),
+                                        token_fetcher_->GetDeviceID(),
+                                        policy_request, this);
+  } else {
+    em::DevicePolicyRequest policy_request;
+    policy_request.set_policy_scope(kChromePolicyScope);
+    em::DevicePolicySettingRequest* setting =
+        policy_request.add_setting_request();
+    setting->set_key(kChromeDevicePolicySettingKey);
+    setting->set_watermark("");
+    backend_->ProcessPolicyRequest(token_fetcher_->GetDeviceToken(),
+                                   token_fetcher_->GetDeviceID(),
+                                   policy_request, this);
+  }
 }
 
 void DeviceManagementPolicyProvider::RefreshTaskExecute() {
   DCHECK(refresh_task_);
   refresh_task_ = NULL;
 
   switch (state_) {
     case STATE_INITIALIZING:
       token_fetcher_->StartFetching();
       return;
@@ skipping 44 matching lines @@
   // observers now.
   if (!initial_fetch_done_ &&
       new_state != STATE_INITIALIZING &&
       new_state != STATE_TOKEN_VALID) {
     initial_fetch_done_ = true;
     NotifyCloudPolicyUpdate();
   }
 
   base::Time now(base::Time::NowFromSystemTime());
   base::Time refresh_at;
-  base::Time last_refresh(cache_->last_policy_refresh_time());
+  base::Time last_refresh(cloud_policy_enabled_ ?
+                          cache2_->last_policy_refresh_time() :
+                          cache_->last_policy_refresh_time());
   if (last_refresh.is_null())
     last_refresh = now;
 
   // Determine when to take the next step.
   switch (state_) {
     case STATE_INITIALIZING:
       refresh_at = now;
       break;
     case STATE_TOKEN_VALID:
       effective_token_fetch_error_delay_ms_ = token_fetch_error_delay_ms_;
@@ skipping 62 matching lines @@
   const FilePath device_management_dir = user_data_dir.Append(
       FILE_PATH_LITERAL("Device Management"));
   if (!file_util::DirectoryExists(device_management_dir)) {
     if (!file_util::CreateDirectory(device_management_dir))
       NOTREACHED();
   }
   return device_management_dir;
 }
 
 }  // namespace policy