Recover policy subsystem correctly after enrollment attempt with a gmail acccount

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 149 matching lines @@
 }
 
 void CloudPolicyController::OnDeviceTokenChanged() {
   if (identity_strategy_->GetDeviceToken().empty())
     SetState(STATE_TOKEN_UNAVAILABLE);
   else
     SetState(STATE_TOKEN_VALID);
 }
 
 void CloudPolicyController::OnCredentialsChanged() {
+  notifier_->Inform(CloudPolicySubsystem::UNENROLLED,
+                    CloudPolicySubsystem::NO_DETAILS,
+                    PolicyNotifier::POLICY_CONTROLLER);
   effective_policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms_;
   SetState(STATE_TOKEN_UNAVAILABLE);
 }
 
 CloudPolicyController::CloudPolicyController(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
     DeviceTokenFetcher* token_fetcher,
     CloudPolicyIdentityStrategy* identity_strategy,
     PolicyNotifier* notifier,
@@ skipping 48 matching lines @@
 }
 
 void CloudPolicyController::FetchToken() {
   std::string username;
   std::string auth_token;
   std::string device_id = identity_strategy_->GetDeviceID();
   std::string machine_id = identity_strategy_->GetMachineID();
   std::string machine_model = identity_strategy_->GetMachineModel();
   em::DeviceRegisterRequest_Type policy_type =
       identity_strategy_->GetPolicyRegisterType();
-  if (identity_strategy_->GetCredentials(&username, &auth_token) &&
-      CanBeInManagedDomain(username)) {
-    token_fetcher_->FetchToken(auth_token, device_id, policy_type,
-                               machine_id, machine_model);
+  if (identity_strategy_->GetCredentials(&username, &auth_token)) {
+    if (CanBeInManagedDomain(username)) {
+      token_fetcher_->FetchToken(auth_token, device_id, policy_type,
+                                 machine_id, machine_model);
+    } else {
+      SetState(STATE_TOKEN_UNMANAGED);
+    }
   }
 }
 
 void CloudPolicyController::SendPolicyRequest() {
   backend_.reset(service_->CreateBackend());
   DCHECK(!identity_strategy_->GetDeviceToken().empty());
   em::DevicePolicyRequest policy_request;
   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());
@@ skipping 123 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