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

chrome/browser/sync_file_system/drive_metadata_store.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/sync_file_system/drive_metadata_store.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 232 matching lines @@
 DriveMetadataStore::~DriveMetadataStore() {
   DCHECK(CalledOnValidThread());
   file_task_runner_->DeleteSoon(FROM_HERE, db_.release());
 }
 
 void DriveMetadataStore::Initialize(const InitializationCallback& callback) {
   DCHECK(CalledOnValidThread());
   DriveMetadataDBContents* contents = new DriveMetadataDBContents;
 
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(InitializeDBOnFileThread, db_.get(), contents),
-      base::Bind(&DriveMetadataStore::DidInitialize, AsWeakPtr(),
-                 callback, base::Owned(contents)));
+      base::Bind(&DriveMetadataStore::DidInitialize,
+                 AsWeakPtr(),
+                 callback,
+                 base::Owned(contents)));
 }
 
 void DriveMetadataStore::DidInitialize(const InitializationCallback& callback,
                                        DriveMetadataDBContents* contents,
                                        SyncStatusCode status) {
   DCHECK(CalledOnValidThread());
   DCHECK(contents);
 
   db_status_ = status;
   if (status != SYNC_STATUS_OK) {
@@ skipping 13 matching lines @@
   InsertReverseMap(disabled_origins_, &origin_by_resource_id_);
 
   callback.Run(status, largest_changestamp_ <= 0);
 }
 
 void DriveMetadataStore::RestoreSyncRootDirectory(
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   std::string* sync_root_directory_resource_id = new std::string;
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::GetSyncRootDirectory,
                  base::Unretained(db_.get()),
                  sync_root_directory_resource_id),
       base::Bind(&DriveMetadataStore::DidRestoreSyncRootDirectory,
-                 AsWeakPtr(), callback,
+                 AsWeakPtr(),
+                 callback,
                  base::Owned(sync_root_directory_resource_id)));
 }
 
 void DriveMetadataStore::DidRestoreSyncRootDirectory(
     const SyncStatusCallback& callback,
     std::string* sync_root_directory_resource_id,
     SyncStatusCode status) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_root_directory_resource_id);
 
   db_status_ = status;
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
   sync_root_directory_resource_id_.swap(*sync_root_directory_resource_id);
   callback.Run(status);
 }
 
 void DriveMetadataStore::RestoreOrigins(
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   ResourceIdByOrigin* incremental_sync_origins = new ResourceIdByOrigin;
   ResourceIdByOrigin* disabled_origins = new ResourceIdByOrigin;
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::GetOrigins,
                  base::Unretained(db_.get()),
                  incremental_sync_origins,
                  disabled_origins),
       base::Bind(&DriveMetadataStore::DidRestoreOrigins,
-                 AsWeakPtr(), callback,
+                 AsWeakPtr(),
+                 callback,
                  base::Owned(incremental_sync_origins),
                  base::Owned(disabled_origins)));
 }
 
 void DriveMetadataStore::DidRestoreOrigins(
     const SyncStatusCallback& callback,
     ResourceIdByOrigin* incremental_sync_origins,
     ResourceIdByOrigin* disabled_origins,
     SyncStatusCode status) {
   DCHECK(CalledOnValidThread());
@@ skipping 20 matching lines @@
   return db_->db_.get();
 }
 
 void DriveMetadataStore::SetLargestChangeStamp(
     int64 largest_changestamp,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
   largest_changestamp_ = largest_changestamp;
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::SetLargestChangestamp,
-                 base::Unretained(db_.get()), largest_changestamp),
+                 base::Unretained(db_.get()),
+                 largest_changestamp),
       base::Bind(&DriveMetadataStore::UpdateDBStatusAndInvokeCallback,
-                 AsWeakPtr(), callback));
+                 AsWeakPtr(),
+                 callback));
 }
 
 int64 DriveMetadataStore::GetLargestChangeStamp() const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
   return largest_changestamp_;
 }
 
 void DriveMetadataStore::UpdateEntry(
     const FileSystemURL& url,
     const DriveMetadata& metadata,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
   DCHECK(!metadata.conflicted() || !metadata.to_be_fetched());
 
   std::pair<PathToMetadata::iterator, bool> result =
       metadata_map_[url.origin()].insert(std::make_pair(url.path(), metadata));
   if (!result.second)
     result.first->second = metadata;
 
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
-      base::Bind(&DriveMetadataDB::UpdateEntry, base::Unretained(db_.get()),
-                 url, metadata),
+      file_task_runner_.get(),
+      FROM_HERE,
+      base::Bind(&DriveMetadataDB::UpdateEntry,
+                 base::Unretained(db_.get()),
+                 url,
+                 metadata),
       base::Bind(&DriveMetadataStore::UpdateDBStatusAndInvokeCallback,
-                 AsWeakPtr(), callback));
+                 AsWeakPtr(),
+                 callback));
 }
 
 void DriveMetadataStore::DeleteEntry(
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
   MetadataMap::iterator found = metadata_map_.find(url.origin());
   if (found == metadata_map_.end()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
     return;
   }
 
   if (found->second.erase(url.path()) == 1) {
     base::PostTaskAndReplyWithResult(
-        file_task_runner_, FROM_HERE,
-        base::Bind(&DriveMetadataDB::DeleteEntry,
-                   base::Unretained(db_.get()), url),
+        file_task_runner_.get(),
+        FROM_HERE,
+        base::Bind(
+            &DriveMetadataDB::DeleteEntry, base::Unretained(db_.get()), url),
         base::Bind(&DriveMetadataStore::UpdateDBStatusAndInvokeCallback,
-                   AsWeakPtr(), callback));
+                   AsWeakPtr(),
+                   callback));
     return;
   }
 
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(callback, SYNC_DATABASE_ERROR_NOT_FOUND));
 }
 
 SyncStatusCode DriveMetadataStore::ReadEntry(const FileSystemURL& url,
                                              DriveMetadata* metadata) const {
@@ skipping 18 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(!IsIncrementalSyncOrigin(origin));
   DCHECK(!IsOriginDisabled(origin));
   DCHECK_EQ(SYNC_STATUS_OK, db_status_);
 
   incremental_sync_origins_.insert(std::make_pair(origin, resource_id));
   origin_by_resource_id_.insert(std::make_pair(resource_id, origin));
 
   // Store a pair of |origin| and |resource_id| in the DB.
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::UpdateOriginAsIncrementalSync,
-                 base::Unretained(db_.get()), origin, resource_id),
+                 base::Unretained(db_.get()),
+                 origin,
+                 resource_id),
       base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 }
 
 void DriveMetadataStore::SetSyncRootDirectory(const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
 
   sync_root_directory_resource_id_ = resource_id;
 
   // Set the resource ID for the sync root directory in the DB.
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::SetSyncRootDirectory,
-                 base::Unretained(db_.get()), resource_id),
+                 base::Unretained(db_.get()),
+                 resource_id),
       base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 }
 
 void DriveMetadataStore::SetOriginRootDirectory(
     const GURL& origin,
     const std::string& resource_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsKnownOrigin(origin));
 
   DriveMetadataDB::OriginSyncType sync_type;
   if (UpdateResourceIdMap(
       &incremental_sync_origins_, &origin_by_resource_id_,
       origin, resource_id)) {
     sync_type = DriveMetadataDB::INCREMENTAL_SYNC_ORIGIN;
   } else if (UpdateResourceIdMap(&disabled_origins_, &origin_by_resource_id_,
                                  origin, resource_id)) {
     sync_type = DriveMetadataDB::DISABLED_ORIGIN;
   } else {
     return;
   }
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::SetOriginRootDirectory,
-                 base::Unretained(db_.get()), origin, sync_type, resource_id),
+                 base::Unretained(db_.get()),
+                 origin,
+                 sync_type,
+                 resource_id),
       base::Bind(&DriveMetadataStore::UpdateDBStatus, AsWeakPtr()));
 }
 
 bool DriveMetadataStore::IsKnownOrigin(const GURL& origin) const {
   DCHECK(CalledOnValidThread());
   return IsIncrementalSyncOrigin(origin) || IsOriginDisabled(origin);
 }
 
 bool DriveMetadataStore::IsIncrementalSyncOrigin(const GURL& origin) const {
   DCHECK(CalledOnValidThread());
@@ skipping 19 matching lines @@
   disabled_origins_.erase(found);
 
   // |Origin| goes back to DriveFileSyncService.pending_batch_sync_origins_
   // only and is not stored in drive_metadata_store.
   found = incremental_sync_origins_.find(origin);
   if (found != incremental_sync_origins_.end())
     incremental_sync_origins_.erase(found);
 
   // Store a pair of |origin| and |resource_id| in the DB.
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::EnableOrigin,
-                 base::Unretained(db_.get()), origin, resource_id),
+                 base::Unretained(db_.get()),
+                 origin,
+                 resource_id),
       base::Bind(&DriveMetadataStore::DidUpdateOrigin, AsWeakPtr(), callback));
 }
 
 void DriveMetadataStore::DisableOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   std::string resource_id;
   std::map<GURL, std::string>::iterator found =
       incremental_sync_origins_.find(origin);
   if (found != incremental_sync_origins_.end()) {
     resource_id = found->second;
     incremental_sync_origins_.erase(found);
   }
 
   if (resource_id.empty()) {
     // |origin| has not been registered yet.
     return;
   }
 
   disabled_origins_.insert(std::make_pair(origin, resource_id));
 
   // Store a pair of |origin| and |resource_id| in the DB.
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
+      file_task_runner_.get(),
+      FROM_HERE,
       base::Bind(&DriveMetadataDB::DisableOrigin,
-                 base::Unretained(db_.get()), origin, resource_id),
+                 base::Unretained(db_.get()),
+                 origin,
+                 resource_id),
       base::Bind(&DriveMetadataStore::DidUpdateOrigin, AsWeakPtr(), callback));
 }
 
 void DriveMetadataStore::RemoveOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   metadata_map_.erase(origin);
 
   std::string resource_id;
   if (EraseIfExists(&incremental_sync_origins_, origin, &resource_id) ||
       EraseIfExists(&disabled_origins_, origin, &resource_id)) {
     origin_by_resource_id_.erase(resource_id);
   }
 
   base::PostTaskAndReplyWithResult(
-      file_task_runner_, FROM_HERE,
-      base::Bind(&DriveMetadataDB::RemoveOrigin,
-                 base::Unretained(db_.get()), origin),
+      file_task_runner_.get(),
+      FROM_HERE,
+      base::Bind(
+          &DriveMetadataDB::RemoveOrigin, base::Unretained(db_.get()), origin),
       base::Bind(&DriveMetadataStore::DidUpdateOrigin, AsWeakPtr(), callback));
 }
 
 void DriveMetadataStore::DidUpdateOrigin(
     const SyncStatusCallback& callback,
     SyncStatusCode status) {
   UpdateDBStatus(status);
   callback.Run(status);
 }
 
@@ skipping 438 matching lines @@
 
     bool result = disabled_origins->insert(
         std::make_pair(origin, origin_resource_id)).second;
     DCHECK(result);
   }
 
   return SYNC_STATUS_OK;
 }
 
 }  // namespace sync_file_system