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

chrome/browser/history/history_backend.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/history/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 134 matching lines @@
       : history_backend_(history_backend) {
   }
 
   // The backend will call this function if it is being destroyed so that we
   // release our reference.
   void Cancel() {
     history_backend_ = NULL;
   }
 
   void RunCommit() {
-    if (history_backend_)
+    if (history_backend_.get())
       history_backend_->Commit();
   }
 
  private:
   friend class base::RefCounted<CommitLaterTask>;
 
   ~CommitLaterTask() {}
 
   scoped_refptr<HistoryBackend> history_backend_;
 };
@@ skipping 100 matching lines @@
       id_(id),
       history_dir_(history_dir),
       expirer_(this, bookmark_service),
       recent_redirects_(kMaxRedirectCount),
       backend_destroy_message_loop_(NULL),
       segment_queried_(false),
       bookmark_service_(bookmark_service) {
 }
 
 HistoryBackend::~HistoryBackend() {
-  DCHECK(!scheduled_commit_) << "Deleting without cleanup";
+  DCHECK(!scheduled_commit_.get()) << "Deleting without cleanup";
   ReleaseDBTasks();
 
 #if defined(OS_ANDROID)
   // Release AndroidProviderBackend before other objects.
   android_provider_backend_.reset();
 #endif
 
   // First close the databases before optionally running the "destroy" task.
   CloseAllDatabases();
 
@@ skipping 2071 matching lines @@
     if (favicon_bitmaps_changed)
       *favicon_bitmaps_changed = true;
   }
 }
 
 bool HistoryBackend::ValidateSetFaviconsParams(
     const std::vector<chrome::FaviconBitmapData>& favicon_bitmap_data) const {
   typedef std::map<GURL, size_t> BitmapsPerIconURL;
   BitmapsPerIconURL num_bitmaps_per_icon_url;
   for (size_t i = 0; i < favicon_bitmap_data.size(); ++i) {
-    if (!favicon_bitmap_data[i].bitmap_data)
+    if (!favicon_bitmap_data[i].bitmap_data.get())
       return false;
 
     const GURL& icon_url = favicon_bitmap_data[i].icon_url;
     if (!num_bitmaps_per_icon_url.count(icon_url))
       num_bitmaps_per_icon_url[icon_url] = 1u;
     else
       ++num_bitmaps_per_icon_url[icon_url];
   }
 
   if (num_bitmaps_per_icon_url.size() > kMaxFaviconsPerPage)
     return false;
 
   for (BitmapsPerIconURL::const_iterator it = num_bitmaps_per_icon_url.begin();
        it != num_bitmaps_per_icon_url.end(); ++it) {
     if (it->second > kMaxFaviconBitmapsPerIconURL)
       return false;
   }
   return true;
 }
 
 bool HistoryBackend::IsFaviconBitmapDataEqual(
     FaviconBitmapID bitmap_id,
     const scoped_refptr<base::RefCountedMemory>& new_bitmap_data) {
-  if (!new_bitmap_data)
+  if (!new_bitmap_data.get())
     return false;
 
   scoped_refptr<base::RefCountedMemory> original_bitmap_data;
   thumbnail_db_->GetFaviconBitmap(bitmap_id,
                                   NULL,
                                   &original_bitmap_data,
                                   NULL);
   return new_bitmap_data->Equals(original_bitmap_data);
 }
 
@@ skipping 238 matching lines @@
     archived_db_->BeginTransaction();
   }
 
   if (text_database_) {
     text_database_->CommitTransaction();
     text_database_->BeginTransaction();
   }
 }
 
 void HistoryBackend::ScheduleCommit() {
-  if (scheduled_commit_)
+  if (scheduled_commit_.get())
     return;
   scheduled_commit_ = new CommitLaterTask(this);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CommitLaterTask::RunCommit, scheduled_commit_.get()),
       base::TimeDelta::FromSeconds(kCommitIntervalSeconds));
 }
 
 void HistoryBackend::CancelScheduledCommit() {
-  if (scheduled_commit_) {
+  if (scheduled_commit_.get()) {
     scheduled_commit_->Cancel();
     scheduled_commit_ = NULL;
   }
 }
 
 void HistoryBackend::ProcessDBTaskImpl() {
   if (!db_) {
     // db went away, release all the refs.
     ReleaseDBTasks();
     return;
@@ skipping 191 matching lines @@
   // databases which will be closed.
   expirer_.SetDatabases(NULL, NULL, NULL, NULL);
 
   // Reopen a new transaction for |db_| for the sake of CloseAllDatabases().
   db_->BeginTransaction();
   CloseAllDatabases();
 }
 
 void HistoryBackend::ProcessDBTask(
     scoped_refptr<HistoryDBTaskRequest> request) {
-  DCHECK(request);
+  DCHECK(request.get());
   if (request->canceled())
     return;
 
   bool task_scheduled = !db_task_requests_.empty();
   // Make sure we up the refcount of the request. ProcessDBTaskImpl will
   // release when done with the task.
   request->AddRef();
   db_task_requests_.push_back(request.get());
   if (!task_scheduled) {
     // No other tasks are scheduled. Process request now.
@@ skipping 214 matching lines @@
   info.url_id = visit.url_id;
   info.time = visit.visit_time;
   info.transition = visit.transition;
   // If we don't have a delegate yet during setup or shutdown, we will drop
   // these notifications.
   if (delegate_)
     delegate_->NotifyVisitDBObserversOnAddVisit(info);
 }
 
 }  // namespace history