Consolidate data storage and notifications in the cloud policy subsystem

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/bind.h"
 #include "base/callback.h"

[Joao da Silva, 2011/07/06 16:45:14]

Nit: callback.h not used

[gfeher, 2011/07/07 13:51:00]

Done.

 #include "base/logging.h"
 #include "base/message_loop.h"

[Joao da Silva, 2011/07/06 16:45:14]

Nit: message_loop.h not used

[gfeher, 2011/07/07 13:51:00]

Done.

 #include "base/rand_util.h"
 #include "base/string_util.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"

[pastarmovj, 2011/07/06 12:11:57]

What does the IWYU say about including the same header both in the .h and the
.cc file?

[gfeher, 2011/07/06 15:14:20]

Do it only at one place...

 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
+#include "chrome/common/guid.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[] = {

[Joao da Silva, 2011/07/06 16:45:14]

Should this static var be in the anonymous namespace instead?

[gfeher, 2011/07/07 13:51:00]

Agreed.

[Joao da Silva, 2011/07/07 16:54:16]

Cool. In that case the static qualifier can be dropped.

[gfeher, 2011/07/08 09:19:14]

Done.

   "@googlemail.com",
   "@gmail.com"
 };
 
 // Checks the domain part of the given username against the list of known
 // non-managed domain names. Returns false if |username| is empty or
 // in a domain known not to be managed.
 static bool CanBeInManagedDomain(const std::string& username) {

[Joao da Silva, 2011/07/06 16:45:14]

Same for this function.

[gfeher, 2011/07/07 13:51:00]

Done.

   if (username.empty()) {
     // This means incognito user in case of ChromiumOS and
     // no logged-in user in case of Chromium (SigninService).
     return false;
   }
   for (size_t i = 0; i < arraysize(kNonManagedDomains); i++) {
     if (EndsWith(username, kNonManagedDomains[i], true)) {
       return false;
     }
   }
@@ skipping 17 matching lines @@
     5 * 60 * 1000;  // 5 minutes
 
 // 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,
+    CloudPolicyData* data,
     PolicyNotifier* notifier) {
   Initialize(service,
              cache,
              token_fetcher,
-             identity_strategy,
+             data,
              notifier,
              new DelayedWorkScheduler);
 }
 
 CloudPolicyController::~CloudPolicyController() {
-  token_fetcher_->RemoveObserver(this);
-  identity_strategy_->RemoveObserver(this);
+  data_->RemoveObserver(this);
   scheduler_->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);
 }
@@ skipping 54 matching lines @@
     case DeviceManagementBackend::kErrorRequestFailed:
     case DeviceManagementBackend::kErrorTemporaryUnavailable: {
       VLOG(1) << "A temporary error in the communication with the policy server"
               << " occurred.";
       // Will retry last operation but gracefully backing off.
       SetState(STATE_POLICY_ERROR);
     }
   }
 }
 
-void CloudPolicyController::OnDeviceTokenAvailable() {
-  identity_strategy_->OnDeviceTokenAvailable(token_fetcher_->GetDeviceToken());
-}
-
 void CloudPolicyController::OnDeviceTokenChanged() {
-  if (identity_strategy_->GetDeviceToken().empty())
+  if (data_->device_token().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_ =
-      kPolicyRefreshErrorDelayInMilliseconds;
-  SetState(STATE_TOKEN_UNAVAILABLE);
+  // This notification is only interesting if we don't have a device token.
+  // If we already have a device token, that must be matching the current

[Joao da Silva, 2011/07/06 16:45:14]

Can that be DCHECK'd?

[gfeher, 2011/07/07 13:51:00]

I think not. The user name cannot be extracted from the token on the client
side, I believe only the server is able to do that.

+  // user, because (1) we always recreate the policy subsystem after user
+  // login (2) tokens are cached per user.
+  if (data_->device_token().empty()) {
+    notifier_->Inform(CloudPolicySubsystem::UNENROLLED,
+                      CloudPolicySubsystem::NO_DETAILS,
+                      PolicyNotifier::POLICY_CONTROLLER);
+    effective_policy_refresh_error_delay_ms_ =
+        kPolicyRefreshErrorDelayInMilliseconds;
+    SetState(STATE_TOKEN_UNAVAILABLE);
+  }
+}
+
+void CloudPolicyController::OnPolicyDataGoingAway() {
+  NOTREACHED();
 }
 
 CloudPolicyController::CloudPolicyController(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
     DeviceTokenFetcher* token_fetcher,
-    CloudPolicyIdentityStrategy* identity_strategy,
+    CloudPolicyData* data,
     PolicyNotifier* notifier,
     DelayedWorkScheduler* scheduler) {
   Initialize(service,
              cache,
              token_fetcher,
-             identity_strategy,
+             data,
              notifier,
              scheduler);
 }
 
 void CloudPolicyController::Initialize(
     DeviceManagementService* service,
     CloudPolicyCacheBase* cache,
     DeviceTokenFetcher* token_fetcher,
-    CloudPolicyIdentityStrategy* identity_strategy,
+    CloudPolicyData* data,
     PolicyNotifier* notifier,
     DelayedWorkScheduler* scheduler) {
   DCHECK(cache);
 
   service_ = service;
   cache_ = cache;
   token_fetcher_ = token_fetcher;
-  identity_strategy_ = identity_strategy;
+  data_ = data;
   notifier_ = notifier;
   state_ = STATE_TOKEN_UNAVAILABLE;
   policy_refresh_rate_ms_ = kPolicyRefreshRateInMilliseconds;
   effective_policy_refresh_error_delay_ms_ =
       kPolicyRefreshErrorDelayInMilliseconds;
   scheduler_.reset(scheduler);
-  token_fetcher_->AddObserver(this);
-  identity_strategy_->AddObserver(this);
-  if (!identity_strategy_->GetDeviceToken().empty())
+  data_->AddObserver(this);
+  if (!data_->device_token().empty())
     SetState(STATE_TOKEN_VALID);
   else
     SetState(STATE_TOKEN_UNAVAILABLE);
 }
 
 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)) {
-    if (CanBeInManagedDomain(username)) {
-      token_fetcher_->FetchToken(auth_token, device_id, policy_type,
-                                 machine_id, machine_model);
+  if (data_->token_cache_loaded() &&
+      !data_->user_name().empty() &&
+      !data_->gaia_token().empty()) {
+    if (CanBeInManagedDomain(data_->user_name())) {
+      // Generate a new random device id. (It'll only be kept if registration
+      // succeeds.)
+      data_->set_device_id(guid::GenerateGUID());
+      token_fetcher_->FetchToken();
     } else {
       SetState(STATE_TOKEN_UNMANAGED);
     }
   }
 }
 
 void CloudPolicyController::SendPolicyRequest() {
   backend_.reset(service_->CreateBackend());
-  DCHECK(!identity_strategy_->GetDeviceToken().empty());
+  DCHECK(!data_->device_token().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());
+  fetch_request->set_policy_type(data_->policy_type());
   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());
   }
   int key_version = 0;
   if (cache_->GetPublicKeyVersion(&key_version))
     fetch_request->set_public_key_version(key_version);
 
-  backend_->ProcessPolicyRequest(identity_strategy_->GetDeviceToken(),
-                                 identity_strategy_->GetDeviceID(),
+  backend_->ProcessPolicyRequest(data_->device_token(),
+                                 data_->device_id(),
                                  policy_request, this);
 }
 
 void CloudPolicyController::DoWork() {
   switch (state_) {
     case STATE_TOKEN_UNAVAILABLE:
     case STATE_TOKEN_ERROR:
       FetchToken();
       return;
     case STATE_TOKEN_VALID:
@@ skipping 88 matching lines @@
 }
 
 int64 CloudPolicyController::GetRefreshDelay() {
   int64 deviation = (kPolicyRefreshDeviationFactorPercent *
                      policy_refresh_rate_ms_) / 100;
   deviation = std::min(deviation, kPolicyRefreshDeviationMaxInMilliseconds);
   return policy_refresh_rate_ms_ - base::RandGenerator(deviation + 1);
 }
 
 }  // namespace policy