Add support for loading user cloud policy on desktop.

chrome/browser/policy/cloud_policy_client.cc

 // Copyright (c) 2012 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_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "chrome/browser/policy/device_management_service.h"
@@ skipping 13 matching lines @@
                                      PolicyScope scope,
                                      StatusProvider* status_provider,
                                      DeviceManagementService* service)
     : machine_id_(machine_id),
       machine_model_(machine_model),
       user_affiliation_(user_affiliation),
       scope_(scope),
       submit_machine_id_(false),
       public_key_version_(-1),
       public_key_version_valid_(false),
-      service_(service),
-      status_provider_(status_provider),
-      status_(DM_STATUS_SUCCESS) {}
+      service_(service),                  // Can be NULL for unit tests.
+      status_provider_(status_provider),  // Can be NULL for unit tests.
+      status_(DM_STATUS_SUCCESS) {
+}
 
 CloudPolicyClient::~CloudPolicyClient() {}
 
 void CloudPolicyClient::SetupRegistration(const std::string& dm_token,
                                           const std::string& client_id) {
   DCHECK(!dm_token.empty());
   DCHECK(!client_id.empty());
   DCHECK(!is_registered());
 
   dm_token_ = dm_token;
   client_id_ = client_id;
   request_job_.reset();
   policy_.reset();
 
   NotifyRegistrationStateChanged();
 }
 
 void CloudPolicyClient::Register(const std::string& auth_token) {
+  DCHECK(service_);
   DCHECK(!auth_token.empty());
   DCHECK(!is_registered());
 
   // Generate a new client ID. This is intentionally done on each new
   // registration request in order to preserve privacy. Reusing IDs would mean
   // the server could track clients by their registration attempts.
   client_id_ = base::GenerateGUID();
 
   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION));
@@ skipping 48 matching lines @@
       request->clear_session_status_report_request();
     }
   }
 
   // Fire the job.
   request_job_->Start(base::Bind(&CloudPolicyClient::OnPolicyFetchCompleted,
                                  base::Unretained(this)));
 }
 
 void CloudPolicyClient::Unregister() {
+  DCHECK(service_);
   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION));
   request_job_->SetDMToken(dm_token_);
   request_job_->SetClientID(client_id_);
   request_job_->GetRequest()->mutable_unregister_request();
   request_job_->Start(base::Bind(&CloudPolicyClient::OnUnregisterCompleted,
                                  base::Unretained(this)));
 }
 
 void CloudPolicyClient::AddObserver(Observer* observer) {
@@ skipping 96 matching lines @@
 
 void CloudPolicyClient::NotifyRegistrationStateChanged() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRegistrationStateChanged(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy