New policy protobuf protocol.

chrome/browser/policy/device_management_policy_provider.cc

Index: chrome/browser/policy/device_management_policy_provider.cc
diff --git a/chrome/browser/policy/device_management_policy_provider.cc b/chrome/browser/policy/device_management_policy_provider.cc
index 315a6d286887c4b5f454a7c107954e641bf383cb..a7d438a559b07065862560e8b971d2e4144b3711 100644
--- a/chrome/browser/policy/device_management_policy_provider.cc
+++ b/chrome/browser/policy/device_management_policy_provider.cc
@@ -10,6 +10,7 @@
 #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"
@@ -40,6 +41,8 @@ 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 {
@@ -65,10 +68,12 @@ class DeviceManagementPolicyProvider::RefreshTask : public CancelableTask {
 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,
@@ -86,13 +91,21 @@ DeviceManagementPolicyProvider::~DeviceManagementPolicyProvider() {
 
 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(
@@ -105,6 +118,16 @@ void DeviceManagementPolicyProvider::HandlePolicyResponse(
   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());
@@ -140,7 +163,10 @@ void DeviceManagementPolicyProvider::OnTokenError() {
 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);
 }
 
@@ -157,6 +183,7 @@ 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,
@@ -166,6 +193,7 @@ DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
     : ConfigurationPolicyProvider(policy_list) {
   Initialize(backend,
              profile,
+             cloud_policy_enabled,
              policy_refresh_rate_ms,
              policy_refresh_deviation_factor_percent,
              policy_refresh_deviation_max_ms,
@@ -177,6 +205,7 @@ DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
 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,
@@ -200,14 +229,22 @@ void DeviceManagementPolicyProvider::Initialize(
   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 {
@@ -226,15 +263,23 @@ void DeviceManagementPolicyProvider::RemoveObserver(
 }
 
 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() {
@@ -299,7 +344,9 @@ void DeviceManagementPolicyProvider::SetState(
 
   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;