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

components/policy/core/common/cloud/device_management_service.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/device_management_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_fetcher.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 const char kPostContentType[] = "application/protobuf";
@@ skipping 104 matching lines @@
 }  // namespace
 
 // Request job implementation used with DeviceManagementService.
 class DeviceManagementRequestJobImpl : public DeviceManagementRequestJob {
  public:
   DeviceManagementRequestJobImpl(
       JobType type,
       const std::string& agent_parameter,
       const std::string& platform_parameter,
       DeviceManagementService* service,
-      net::URLRequestContextGetter* request_context);
+      const scoped_refptr<net::URLRequestContextGetter>& request_context);
   virtual ~DeviceManagementRequestJobImpl();
 
   // Handles the URL request response.
   void HandleResponse(const net::URLRequestStatus& status,
                       int response_code,
                       const net::ResponseCookies& cookies,
                       const std::string& data);
 
   // Gets the URL to contact.
   GURL GetURL(const std::string& server_url);
@@ skipping 20 matching lines @@
   // Pointer to the service this job is associated with.
   DeviceManagementService* service_;
 
   // Whether the BYPASS_PROXY flag should be set by ConfigureRequest().
   bool bypass_proxy_;
 
   // Number of times that this job has been retried due to ERR_NETWORK_CHANGED.
   int retries_count_;
 
   // The request context to use for this job.
-  net::URLRequestContextGetter* request_context_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementRequestJobImpl);
 };
 
 DeviceManagementRequestJobImpl::DeviceManagementRequestJobImpl(
     JobType type,
     const std::string& agent_parameter,
     const std::string& platform_parameter,
     DeviceManagementService* service,
-    net::URLRequestContextGetter* request_context)
+    const scoped_refptr<net::URLRequestContextGetter>& request_context)
     : DeviceManagementRequestJob(type, agent_parameter, platform_parameter),
       service_(service),
       bypass_proxy_(false),
       retries_count_(0),
-      request_context_(request_context) {}
+      request_context_(request_context) {
+}
 
 DeviceManagementRequestJobImpl::~DeviceManagementRequestJobImpl() {
   service_->RemoveJob(this);
 }
 
 void DeviceManagementRequestJobImpl::Run() {
   service_->AddJob(this);
 }
 
 void DeviceManagementRequestJobImpl::HandleResponse(
@@ skipping 82 matching lines @@
       result += '&';
     result += net::EscapeQueryParamValue(entry->first, true);
     result += '=';
     result += net::EscapeQueryParamValue(entry->second, true);
   }
   return GURL(result);
 }
 
 void DeviceManagementRequestJobImpl::ConfigureRequest(
     net::URLFetcher* fetcher) {
-  fetcher->SetRequestContext(request_context_);
+  // TODO(dcheng): It might make sense to make this take a const
+  // scoped_refptr<T>& too eventually.
+  fetcher->SetRequestContext(request_context_.get());
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES |
                         net::LOAD_DISABLE_CACHE |
                         (bypass_proxy_ ? net::LOAD_BYPASS_PROXY : 0));
   std::string payload;
   CHECK(request_.SerializeToString(&payload));
   fetcher->SetUploadData(kPostContentType, payload);
   std::string extra_headers;
   if (!gaia_token_.empty())
     extra_headers += kServiceTokenAuthHeader + gaia_token_ + "\n";
@@ skipping 94 matching lines @@
 const int DeviceManagementService::kURLFetcherID = 0xde71ce1d;
 
 DeviceManagementService::~DeviceManagementService() {
   // All running jobs should have been cancelled by now.
   DCHECK(pending_jobs_.empty());
   DCHECK(queued_jobs_.empty());
 }
 
 DeviceManagementRequestJob* DeviceManagementService::CreateJob(
     DeviceManagementRequestJob::JobType type,
-    net::URLRequestContextGetter* request_context) {
+    const scoped_refptr<net::URLRequestContextGetter>& request_context) {
   return new DeviceManagementRequestJobImpl(
       type,
       configuration_->GetAgentParameter(),
       configuration_->GetPlatformParameter(),
       this,
       request_context);
 }
 
 void DeviceManagementService::ScheduleInitialization(int64 delay_milliseconds) {
   if (initialized_)
@@ skipping 89 matching lines @@
     }
   }
 
   const JobQueue::iterator elem =
       std::find(queued_jobs_.begin(), queued_jobs_.end(), job);
   if (elem != queued_jobs_.end())
     queued_jobs_.erase(elem);
 }
 
 }  // namespace policy