Manual fixups in components/policy for scoped_refptr operator T* removal

components/policy/core/common/cloud/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 "components/policy/core/common/cloud/cloud_policy_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 90 matching lines @@
 
   if (client_id.empty()) {
     // 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();
   } else {
     client_id_ = client_id;
   }
 
+  // TODO(dcheng): Potentially sketchy. This gets passed to
+  // DeviceManagementRequestJobImpl, which only keeps a raw pointer to it.

[bartfab (slow), 2014/08/29 08:49:03]

The job is owned by |this| and |this| will go away before the system request
context getter, so a raw pointer should work in practice. But I see no harm in
keeping a scoped_refptr in DeviceManagementRequestJobImpl instead. It makes it
much more explicit that the job expects the context getter not to go away during
its lifetime.

[dcheng, 2014/08/29 09:08:36]

Done.

   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION,
-                          GetRequestContext()));
+                          GetRequestContext().get()));
   request_job_->SetOAuthToken(auth_token);
   request_job_->SetClientID(client_id_);
 
   em::DeviceRegisterRequest* request =
       request_job_->GetRequest()->mutable_register_request();
   if (!client_id.empty())
     request->set_reregister(true);
   request->set_type(type);
   if (!machine_id_.empty())
     request->set_machine_id(machine_id_);
@@ skipping 19 matching lines @@
   invalidation_version_ = version;
   invalidation_payload_ = payload;
 }
 
 void CloudPolicyClient::FetchPolicy() {
   CHECK(is_registered());
   CHECK(!namespaces_to_fetch_.empty());
 
   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH,
-                          GetRequestContext()));
+                          GetRequestContext().get()));
   request_job_->SetDMToken(dm_token_);
   request_job_->SetClientID(client_id_);
   request_job_->SetUserAffiliation(user_affiliation_);
 
   em::DeviceManagementRequest* request = request_job_->GetRequest();
 
   // Build policy fetch requests.
   em::DevicePolicyRequest* policy_request = request->mutable_policy_request();
   for (NamespaceSet::iterator it = namespaces_to_fetch_.begin();
        it != namespaces_to_fetch_.end(); ++it) {
@@ skipping 56 matching lines @@
 
   // Fire the job.
   request_job_->Start(base::Bind(&CloudPolicyClient::OnPolicyFetchCompleted,
                                  base::Unretained(this)));
 }
 
 void CloudPolicyClient::FetchRobotAuthCodes(const std::string& auth_token) {
   CHECK(is_registered());
   DCHECK(!auth_token.empty());
 
-  request_job_.reset(service_->CreateJob(
-      DeviceManagementRequestJob::TYPE_API_AUTH_CODE_FETCH,
-      GetRequestContext()));
+  request_job_.reset(
+      service_->CreateJob(DeviceManagementRequestJob::TYPE_API_AUTH_CODE_FETCH,
+                          GetRequestContext().get()));
   // The credentials of a domain user are needed in order to mint a new OAuth2
   // authorization token for the robot account.
   request_job_->SetOAuthToken(auth_token);
   request_job_->SetDMToken(dm_token_);
   request_job_->SetClientID(client_id_);
 
   em::DeviceServiceApiAccessRequest* request =
       request_job_->GetRequest()->mutable_service_api_access_request();
   request->set_oauth2_client_id(
       GaiaUrls::GetInstance()->oauth2_chrome_client_id());
   request->add_auth_scope(GaiaConstants::kAnyApiOAuth2Scope);
 
   request_job_->Start(
       base::Bind(&CloudPolicyClient::OnFetchRobotAuthCodesCompleted,
                  base::Unretained(this)));
 }
 
 void CloudPolicyClient::Unregister() {
   DCHECK(service_);
   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_UNREGISTRATION,
-                          GetRequestContext()));
+                          GetRequestContext().get()));
   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::UploadCertificate(
     const std::string& certificate_data,
     const CloudPolicyClient::StatusCallback& callback) {
   CHECK(is_registered());
   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_UPLOAD_CERTIFICATE,
-                          GetRequestContext()));
+                          GetRequestContext().get()));
   request_job_->SetDMToken(dm_token_);
   request_job_->SetClientID(client_id_);
 
   em::DeviceManagementRequest* request = request_job_->GetRequest();
   request->mutable_cert_upload_request()->set_device_certificate(
       certificate_data);
 
   DeviceManagementRequestJob::Callback job_callback = base::Bind(
       &CloudPolicyClient::OnCertificateUploadCompleted,
       base::Unretained(this),
@@ skipping 191 matching lines @@
 
 void CloudPolicyClient::NotifyRobotAuthCodesFetched() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRobotAuthCodesFetched(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy