Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/browsing_data/browsing_data_remover.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/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 727 matching lines @@
 void BrowsingDataRemover::ClearedCache() {
   waiting_for_clear_cache_ = false;
 
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearCacheOnIOThread() {
   // This function should be called on the IO thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(STATE_NONE, next_cache_state_);
-  DCHECK(main_context_getter_);
-  DCHECK(media_context_getter_);
+  DCHECK(main_context_getter_.get());
+  DCHECK(media_context_getter_.get());
 
   next_cache_state_ = STATE_CREATE_MAIN;
   DoClearCache(net::OK);
 }
 
 // The expected state sequence is STATE_NONE --> STATE_CREATE_MAIN -->
 // STATE_DELETE_MAIN --> STATE_CREATE_MEDIA --> STATE_DELETE_MEDIA -->
 // STATE_DONE, and any errors are ignored.
 void BrowsingDataRemover::DoClearCache(int rv) {
   DCHECK_NE(STATE_NONE, next_cache_state_);
 
   while (rv != net::ERR_IO_PENDING && next_cache_state_ != STATE_NONE) {
     switch (next_cache_state_) {
       case STATE_CREATE_MAIN:
       case STATE_CREATE_MEDIA: {
         // Get a pointer to the cache.
         net::URLRequestContextGetter* getter =
-            (next_cache_state_ == STATE_CREATE_MAIN) ?
-                main_context_getter_ : media_context_getter_;
+            (next_cache_state_ == STATE_CREATE_MAIN)
+                ? main_context_getter_.get()
+                : media_context_getter_.get();
         net::HttpTransactionFactory* factory =
             getter->GetURLRequestContext()->http_transaction_factory();
 
         next_cache_state_ = (next_cache_state_ == STATE_CREATE_MAIN) ?
                                 STATE_DELETE_MAIN : STATE_DELETE_MEDIA;
         rv = factory->GetCache()->GetBackend(
             &cache_, base::Bind(&BrowsingDataRemover::DoClearCache,
                                 base::Unretained(this)));
         break;
       }
@@ skipping 91 matching lines @@
       base::Bind(&BrowsingDataRemover::OnGotLocalStorageUsageInfo,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::OnGotLocalStorageUsageInfo(
     const std::vector<dom_storage::LocalStorageUsageInfo>& infos) {
   DCHECK(waiting_for_clear_local_storage_);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (size_t i = 0; i < infos.size(); ++i) {
-    if (!BrowsingDataHelper::DoesOriginMatchMask(infos[i].origin,
-                                                 origin_set_mask_,
-                                                 special_storage_policy_))
+    if (!BrowsingDataHelper::DoesOriginMatchMask(
+            infos[i].origin, origin_set_mask_, special_storage_policy_.get()))
       continue;
 
     if (infos[i].last_modified >= delete_begin_ &&
         infos[i].last_modified <= delete_end_) {
       dom_storage_context_->DeleteLocalStorage(infos[i].origin);
     }
   }
   waiting_for_clear_local_storage_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearSessionStorageOnUIThread() {
   DCHECK(waiting_for_clear_session_storage_);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   dom_storage_context_->GetSessionStorageUsage(
       base::Bind(&BrowsingDataRemover::OnGotSessionStorageUsageInfo,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::OnGotSessionStorageUsageInfo(
     const std::vector<dom_storage::SessionStorageUsageInfo>& infos) {
   DCHECK(waiting_for_clear_session_storage_);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (size_t i = 0; i < infos.size(); ++i) {
-    if (!BrowsingDataHelper::DoesOriginMatchMask(infos[i].origin,
-                                                 origin_set_mask_,
-                                                 special_storage_policy_))
+    if (!BrowsingDataHelper::DoesOriginMatchMask(
+            infos[i].origin, origin_set_mask_, special_storage_policy_.get()))
       continue;
 
     dom_storage_context_->DeleteSessionStorage(infos[i]);
   }
   waiting_for_clear_session_storage_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearQuotaManagedDataOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 39 matching lines @@
   // Walk through the origins passed in, delete quota of |type| from each that
   // matches the |origin_set_mask_|.
   std::set<GURL>::const_iterator origin;
   for (origin = origins.begin(); origin != origins.end(); ++origin) {
     // TODO(mkwst): Clean this up, it's slow. http://crbug.com/130746
     if (!remove_origin_.is_empty() && remove_origin_ != origin->GetOrigin())
       continue;
 
     if (!BrowsingDataHelper::DoesOriginMatchMask(origin->GetOrigin(),
                                                  origin_set_mask_,
-                                                 special_storage_policy_))
+                                                 special_storage_policy_.get()))
       continue;
 
     ++quota_managed_origins_to_delete_count_;
     quota_manager_->DeleteOriginData(
         origin->GetOrigin(), type,
         BrowsingDataRemover::GenerateQuotaClientMask(remove_mask_),
         base::Bind(&BrowsingDataRemover::OnQuotaManagedOriginDeletion,
                    base::Unretained(this), origin->GetOrigin(), type));
   }
 
@@ skipping 111 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_form_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_autofill_origin_urls_ = false;
   NotifyAndDeleteIfDone();
 }