Send policy blobs to session_manager

chrome/browser/policy/cloud_policy_controller.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/cloud_policy_controller.h"
 
 #include <algorithm>
 
+#include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
-#include "chrome/browser/policy/cloud_policy_cache.h"
+#include "chrome/browser/policy/cloud_policy_cache_base.h"
 #include "chrome/browser/policy/cloud_policy_subsystem.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 
 // Domain names that are known not to be managed.
 // We don't register the device when such a user logs in.
 static const char* kNonManagedDomains[] = {
   "@googlemail.com",
   "@gmail.com"
 };
@@ skipping 29 matching lines @@
 // These are the base values for delays before retrying after an error. They
 // will be doubled each time they are used.
 static const int64 kPolicyRefreshErrorDelayInMilliseconds =
     3 * 1000;  // 3 seconds
 
 // Default value for the policy refresh rate.
 static const int kPolicyRefreshRateInMilliseconds =
     3 * 60 * 60 * 1000;  // 3 hours.
 
 CloudPolicyController::CloudPolicyController(
-    CloudPolicyCache* cache,
+    CloudPolicyCacheBase* cache,
     DeviceManagementBackend* backend,
     DeviceTokenFetcher* token_fetcher,
     CloudPolicyIdentityStrategy* identity_strategy)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   Initialize(cache,
              backend,
              token_fetcher,
              identity_strategy,
              kPolicyRefreshRateInMilliseconds,
              kPolicyRefreshDeviationFactorPercent,
@@ skipping 21 matching lines @@
     return;
 
   if (response.response_size() > 0) {
     if (response.response_size() > 1) {
       LOG(WARNING) << "More than one policy in the response of the device "
                    << "management server, discarding.";
     }
     // Use the new version of the protocol
     cache_->SetPolicy(response.response(0));
     SetState(STATE_POLICY_VALID);
-  } else {
-    cache_->SetDevicePolicy(response);
-    SetState(STATE_POLICY_VALID);
   }
 }
 
 void CloudPolicyController::OnError(DeviceManagementBackend::ErrorCode code) {
   if (state_ == STATE_TOKEN_UNAVAILABLE)
     return;
 
   if (code == DeviceManagementBackend::kErrorServiceDeviceNotFound ||
       code == DeviceManagementBackend::kErrorServiceManagementTokenInvalid) {
     LOG(WARNING) << "The device token was either invalid or unknown to the "
@@ skipping 17 matching lines @@
     SetState(STATE_TOKEN_UNAVAILABLE);
   else
     SetState(STATE_TOKEN_VALID);
 }
 
 void CloudPolicyController::OnCredentialsChanged() {
   SetState(STATE_TOKEN_UNAVAILABLE);
 }
 
 CloudPolicyController::CloudPolicyController(
-    CloudPolicyCache* cache,
+    CloudPolicyCacheBase* cache,
     DeviceManagementBackend* backend,
     DeviceTokenFetcher* token_fetcher,
     CloudPolicyIdentityStrategy* identity_strategy,
     int64 policy_refresh_rate_ms,
     int policy_refresh_deviation_factor_percent,
     int64 policy_refresh_deviation_max_ms,
     int64 policy_refresh_error_delay_ms)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   Initialize(cache,
              backend,
              token_fetcher,
              identity_strategy,
              policy_refresh_rate_ms,
              policy_refresh_deviation_factor_percent,
              policy_refresh_deviation_max_ms,
              policy_refresh_error_delay_ms);
 }
 
 void CloudPolicyController::Initialize(
-    CloudPolicyCache* cache,
+    CloudPolicyCacheBase* cache,
     DeviceManagementBackend* backend,
     DeviceTokenFetcher* token_fetcher,
     CloudPolicyIdentityStrategy* identity_strategy,
     int64 policy_refresh_rate_ms,
     int policy_refresh_deviation_factor_percent,
     int64 policy_refresh_deviation_max_ms,
     int64 policy_refresh_error_delay_ms) {
   DCHECK(cache);
 
   cache_ = cache;
@@ skipping 36 matching lines @@
   em::PolicyFetchRequest* fetch_request = policy_request.add_request();
   fetch_request->set_signature_type(em::PolicyFetchRequest::SHA1_RSA);
   fetch_request->set_policy_type(identity_strategy_->GetPolicyType());
   if (!cache_->is_unmanaged() &&
       !cache_->last_policy_refresh_time().is_null()) {
     base::TimeDelta timestamp =
         cache_->last_policy_refresh_time() - base::Time::UnixEpoch();
     fetch_request->set_timestamp(timestamp.InMilliseconds());
   }
 
-  // TODO(gfeher): Remove the following block when the server is migrated.
-  // Set fields for the old protocol.
-  policy_request.set_policy_scope(kChromePolicyScope);
-  em::DevicePolicySettingRequest* setting =
-      policy_request.add_setting_request();
-  setting->set_key(kChromeDevicePolicySettingKey);
-  setting->set_watermark("");
-
   backend_->ProcessPolicyRequest(identity_strategy_->GetDeviceToken(),
                                  identity_strategy_->GetDeviceID(),
                                  policy_request, this);
 }
 
 void CloudPolicyController::DoDelayedWork() {
   DCHECK(delayed_work_task_);
   delayed_work_task_ = NULL;
 
   switch (state_) {
@@ skipping 59 matching lines @@
 }
 
 int64 CloudPolicyController::GetRefreshDelay() {
   int64 deviation = (policy_refresh_deviation_factor_percent_ *
                      policy_refresh_rate_ms_) / 100;
   deviation = std::min(deviation, policy_refresh_deviation_max_ms_);
   return policy_refresh_rate_ms_ - base::RandGenerator(deviation + 1);
 }
 
 }  // namespace policy