Move writing information to the lockbox after registering with the DM server.

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"
@@ skipping 48 matching lines @@
 // Default value for the policy refresh rate.
 static const int kPolicyRefreshRateInMilliseconds =
     3 * 60 * 60 * 1000;  // 3 hours.
 
 CloudPolicyController::CloudPolicyController(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
     DeviceTokenFetcher* token_fetcher,
     CloudPolicyIdentityStrategy* identity_strategy,
     PolicyNotifier* notifier)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+    : stop_after_token_fetch_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   Initialize(service,
              cache,
              token_fetcher,
              identity_strategy,
              notifier,
              kPolicyRefreshRateInMilliseconds,
              kPolicyRefreshDeviationFactorPercent,
              kPolicyRefreshDeviationMaxInMilliseconds,
              kPolicyRefreshErrorDelayInMilliseconds);
 }
 
 CloudPolicyController::~CloudPolicyController() {
   token_fetcher_->RemoveObserver(this);
   identity_strategy_->RemoveObserver(this);
   CancelDelayedWork();
 }
 
 void CloudPolicyController::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);
 }
 
+void CloudPolicyController::StopAfterTokenFetch(bool enable) {
+  stop_after_token_fetch_ = enable;
+}
+
 void CloudPolicyController::Retry() {
   CancelDelayedWork();
   DoWork();
 }
 
 void CloudPolicyController::StopAutoRetry() {
   CancelDelayedWork();
   backend_.reset();
 }
 
@@ skipping 194 matching lines @@
 void CloudPolicyController::SetState(
     CloudPolicyController::ControllerState new_state) {
   state_ = new_state;
   backend_.reset();  // Discard any pending requests.
 
   base::Time now(base::Time::NowFromSystemTime());
   base::Time refresh_at;
   base::Time last_refresh(cache_->last_policy_refresh_time());
   if (last_refresh.is_null())
     last_refresh = now;
-
+  LOG(ERROR) << "$$$ state : " << state_;
   // Determine when to take the next step.
   bool inform_notifier_done = false;
   switch (state_) {
     case STATE_TOKEN_UNMANAGED:
       notifier_->Inform(CloudPolicySubsystem::UNMANAGED,
                         CloudPolicySubsystem::NO_DETAILS,
                         PolicyNotifier::POLICY_CONTROLLER);
       break;
     case STATE_TOKEN_UNAVAILABLE:
       // The controller is not yet initialized and needs to immediately fetch
       // token and policy if present.
+      refresh_at = now;
+      break;
     case STATE_TOKEN_VALID:
       // Immediately try to fetch the token on initialization or policy after a
       // token update. Subsequent retries will respect the back-off strategy.
-      refresh_at = now;
-      // |notifier_| isn't informed about anything at this point, we wait for
-      // the result of the next action first.
+      if (!stop_after_token_fetch_) {
+        refresh_at = now;
+        LOG(ERROR) << "$$$ Will fetch!";
+      } else {
+        LOG(ERROR) << "$$$ Will notify!";
+        stop_after_token_fetch_ = false;
+        notifier_->Inform(CloudPolicySubsystem::TOKEN_FETCHED,
+                          CloudPolicySubsystem::NO_DETAILS,
+                          PolicyNotifier::POLICY_CONTROLLER);
+      }
       break;
     case STATE_POLICY_VALID:
       // Delay is only reset if the policy fetch operation was successful. This
       // will ensure the server won't get overloaded with retries in case of
       // a bug on either side.
       effective_policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms_;
       refresh_at =
           last_refresh + base::TimeDelta::FromMilliseconds(GetRefreshDelay());
       notifier_->Inform(CloudPolicySubsystem::SUCCESS,
                         CloudPolicySubsystem::NO_DETAILS,
@@ skipping 38 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