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

chrome/browser/search/instant_service.cc

 // Copyright 2013 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/search/instant_service.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/instant_io_context.h"
@@ skipping 92 matching lines @@
   std::string path = url.path().substr(1);
 
   // Check that path is of Most Visited item ID form.
   InstantRestrictedID dummy = 0;
   return base::StringToInt(path, &dummy);
 }
 
 void InstantService::AddInstantProcess(int process_id) {
   process_ids_.insert(process_id);
 
-  if (instant_io_context_) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&InstantIOContext::AddInstantProcessOnIO,
-                   instant_io_context_, process_id));
+  if (instant_io_context_.get()) {
+    BrowserThread::PostTask(BrowserThread::IO,
+                            FROM_HERE,
+                            base::Bind(&InstantIOContext::AddInstantProcessOnIO,
+                                       instant_io_context_,
+                                       process_id));
   }
 }
 
 bool InstantService::IsInstantProcess(int process_id) const {
   return process_ids_.find(process_id) != process_ids_.end();
 }
 
 void InstantService::AddMostVisitedItems(
     const std::vector<InstantMostVisitedItem>& items) {
   most_visited_item_cache_.AddItems(items);
 
   // Post task to the IO thread to copy the data.
-  if (instant_io_context_) {
+  if (instant_io_context_.get()) {
     std::vector<InstantMostVisitedItemIDPair> items;
     most_visited_item_cache_.GetCurrentItems(&items);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&InstantIOContext::AddMostVisitedItemsOnIO,
                    instant_io_context_,
                    items));
   }
 }
 
 void InstantService::GetCurrentMostVisitedItems(
     std::vector<InstantMostVisitedItemIDPair>* items) const {
   most_visited_item_cache_.GetCurrentItems(items);
 }
 
 bool InstantService::GetMostVisitedItemForID(
     InstantRestrictedID most_visited_item_id,
     InstantMostVisitedItem* item) const {
   return most_visited_item_cache_.GetItemWithRestrictedID(
       most_visited_item_id, item);
 }
 
 void InstantService::Shutdown() {
   process_ids_.clear();
 
-  if (instant_io_context_) {
+  if (instant_io_context_.get()) {
     BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
+        BrowserThread::IO,
+        FROM_HERE,
         base::Bind(&InstantIOContext::ClearInstantProcessesOnIO,
                    instant_io_context_));
   }
   instant_io_context_ = NULL;
 }
 
 void InstantService::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
       int process_id =
           content::Source<content::RenderProcessHost>(source)->GetID();
       process_ids_.erase(process_id);
 
-      if (instant_io_context_) {
+      if (instant_io_context_.get()) {
         BrowserThread::PostTask(
-            BrowserThread::IO, FROM_HERE,
+            BrowserThread::IO,
+            FROM_HERE,
             base::Bind(&InstantIOContext::RemoveInstantProcessOnIO,
-                       instant_io_context_, process_id));
+                       instant_io_context_,
+                       process_id));
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification type in InstantService.";
   }
 }