Update chrome/ to use WeakPtr<T>::get() instead of implicit "operator T*"

chrome/browser/sync_file_system/drive/local_change_processor_delegate.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/sync_file_system/drive/local_change_processor_delegate.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "chrome/browser/sync_file_system/drive/api_util.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_service.h"
@@ skipping 14 matching lines @@
       local_change_(local_change),
       local_path_(local_path),
       local_metadata_(local_metadata),
       has_drive_metadata_(false),
       has_remote_change_(false),
       weak_factory_(this) {}
 
 LocalChangeProcessorDelegate::~LocalChangeProcessorDelegate() {}
 
 void LocalChangeProcessorDelegate::Run(const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   // TODO(nhiroki): support directory operations (http://crbug.com/161442).
   DCHECK(IsSyncFSDirectoryOperationEnabled() || !local_change_.IsDirectory());
 
   has_drive_metadata_ =
       metadata_store()->ReadEntry(url_, &drive_metadata_) == SYNC_STATUS_OK;
 
   if (!has_drive_metadata_)
     drive_metadata_.set_md5_checksum(std::string());
 
   sync_service_->EnsureOriginRootDirectory(
       url_.origin(),
       base::Bind(&LocalChangeProcessorDelegate::DidGetOriginRoot,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void LocalChangeProcessorDelegate::DidGetOriginRoot(
     const SyncStatusCallback& callback,
     SyncStatusCode status,
     const std::string& origin_resource_id) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
   origin_resource_id_ = origin_resource_id;
 
   has_remote_change_ =
@@ skipping 47 matching lines @@
       callback.Run(SYNC_STATUS_FAILED);
       return;
     }
   }
   NOTREACHED();
   callback.Run(SYNC_STATUS_FAILED);
 }
 
 void LocalChangeProcessorDelegate::UploadNewFile(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   api_util()->UploadNewFile(
       origin_resource_id_,
       local_path_,
       DriveFileSyncService::PathToTitle(url_.path()),
       base::Bind(&LocalChangeProcessorDelegate::DidUploadNewFile,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalChangeProcessorDelegate::DidUploadNewFile(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id,
     const std::string& md5) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   switch (error) {
     case google_apis::HTTP_CREATED:
       UpdateMetadata(
           resource_id, md5, DriveMetadata::RESOURCE_TYPE_FILE,
           base::Bind(&LocalChangeProcessorDelegate::DidApplyLocalChange,
                      weak_factory_.GetWeakPtr(), callback, error));
       sync_service_->NotifyObserversFileStatusChanged(
           url_,
           SYNC_FILE_STATUS_SYNCED,
           SYNC_ACTION_ADDED,
           SYNC_DIRECTION_LOCAL_TO_REMOTE);
       return;
     case google_apis::HTTP_CONFLICT:
       HandleCreationConflict(resource_id, DriveMetadata::RESOURCE_TYPE_FILE,
                              callback);
       return;
     default:
       callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
   }
 }
 
 void LocalChangeProcessorDelegate::CreateDirectory(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(IsSyncFSDirectoryOperationEnabled());
   api_util()->CreateDirectory(
       origin_resource_id_,
       DriveFileSyncService::PathToTitle(url_.path()),
       base::Bind(&LocalChangeProcessorDelegate::DidCreateDirectory,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalChangeProcessorDelegate::DidCreateDirectory(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   switch (error) {
     case google_apis::HTTP_SUCCESS:
     case google_apis::HTTP_CREATED: {
       UpdateMetadata(
           resource_id, std::string(), DriveMetadata::RESOURCE_TYPE_FOLDER,
           base::Bind(&LocalChangeProcessorDelegate::DidApplyLocalChange,
                      weak_factory_.GetWeakPtr(), callback, error));
       sync_service_->NotifyObserversFileStatusChanged(
           url_,
           SYNC_FILE_STATUS_SYNCED,
           SYNC_ACTION_ADDED,
           SYNC_DIRECTION_LOCAL_TO_REMOTE);
       return;
     }
 
     case google_apis::HTTP_CONFLICT:
       // There were conflicts and a file was left.
       // TODO(kinuko): Handle the latter case (http://crbug.com/237090).
       // Fall-through
 
     default:
       callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
   }
 }
 
 void LocalChangeProcessorDelegate::UploadExistingFile(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(has_drive_metadata_);
   api_util()->UploadExistingFile(
       drive_metadata_.resource_id(),
       drive_metadata_.md5_checksum(),
       local_path_,
       base::Bind(&LocalChangeProcessorDelegate::DidUploadExistingFile,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalChangeProcessorDelegate::DidUploadExistingFile(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     const std::string& resource_id,
     const std::string& md5) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(has_drive_metadata_);
   switch (error) {
     case google_apis::HTTP_SUCCESS:
       UpdateMetadata(
           resource_id, md5, DriveMetadata::RESOURCE_TYPE_FILE,
           base::Bind(&LocalChangeProcessorDelegate::DidApplyLocalChange,
                      weak_factory_.GetWeakPtr(), callback, error));
       sync_service_->NotifyObserversFileStatusChanged(
@@ skipping 20 matching lines @@
           GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(SYNC_STATUS_OK, status);
       callback.Run(status);
       return;
     }
   }
 }
 
 void LocalChangeProcessorDelegate::DeleteFile(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(has_drive_metadata_);
   api_util()->DeleteFile(
       drive_metadata_.resource_id(),
       drive_metadata_.md5_checksum(),
       base::Bind(&LocalChangeProcessorDelegate::DidDeleteFile,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalChangeProcessorDelegate::DeleteDirectory(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(IsSyncFSDirectoryOperationEnabled());
   DCHECK(has_drive_metadata_);
   // This does not handle recursive directory deletion
   // (which should not happen other than after a restart).
   api_util()->DeleteFile(
       drive_metadata_.resource_id(),
       std::string(),  // empty md5
       base::Bind(&LocalChangeProcessorDelegate::DidDeleteFile,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalChangeProcessorDelegate::DidDeleteFile(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(has_drive_metadata_);
 
   switch (error) {
     // Regardless of whether the deletion has succeeded (HTTP_SUCCESS) or
     // has failed with ETag conflict error (HTTP_PRECONDITION or HTTP_CONFLICT)
     // we should just delete the drive_metadata.
     // In the former case the file should be just gone now, and
     // in the latter case the remote change will be applied in a future
@@ skipping 19 matching lines @@
           GDataErrorCodeToSyncStatusCodeWrapper(error);
       DCHECK_NE(SYNC_STATUS_OK, status);
       callback.Run(status);
       return;
     }
   }
 }
 
 void LocalChangeProcessorDelegate::ResolveToLocal(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   api_util()->DeleteFile(
       drive_metadata_.resource_id(),
       drive_metadata_.md5_checksum(),
       base::Bind(
           &LocalChangeProcessorDelegate::DidDeleteFileToResolveToLocal,
           weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalChangeProcessorDelegate::DidDeleteFileToResolveToLocal(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   if (error != google_apis::HTTP_SUCCESS &&
       error != google_apis::HTTP_NOT_FOUND) {
     remote_change_handler()->RemoveChangeForURL(url_);
     callback.Run(GDataErrorCodeToSyncStatusCodeWrapper(error));
     return;
   }
 
   DCHECK_NE(SYNC_FILE_TYPE_UNKNOWN, local_metadata_.file_type);
   if (local_metadata_.file_type == SYNC_FILE_TYPE_FILE) {
     UploadNewFile(callback);
     return;
   }
 
   DCHECK(IsSyncFSDirectoryOperationEnabled());
   DCHECK_EQ(SYNC_FILE_TYPE_DIRECTORY, local_metadata_.file_type);
   CreateDirectory(callback);
 }
 
 void LocalChangeProcessorDelegate::ResolveToRemote(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   // Mark the file as to-be-fetched.
   DCHECK(!drive_metadata_.resource_id().empty());
 
   SyncFileType type = remote_change_.change.file_type();
   SetMetadataToBeFetched(
       DriveFileSyncService::SyncFileTypeToDriveMetadataResourceType(type),
       base::Bind(&LocalChangeProcessorDelegate::DidResolveToRemote,
                  weak_factory_.GetWeakPtr(), callback));
   // The synced notification will be dispatched when the remote file is
   // downloaded.
 }
 
 void LocalChangeProcessorDelegate::DidResolveToRemote(
     const SyncStatusCallback& callback,
     SyncStatusCode status) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(has_drive_metadata_);
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
   SyncFileType file_type = SYNC_FILE_TYPE_FILE;
   if (drive_metadata_.type() == DriveMetadata::RESOURCE_TYPE_FOLDER)
     file_type = SYNC_FILE_TYPE_DIRECTORY;
   sync_service_->AppendFetchChange(
       url_.origin(), url_.path(), drive_metadata_.resource_id(), file_type);
   callback.Run(status);
 }
 
 void LocalChangeProcessorDelegate::DidApplyLocalChange(
     const SyncStatusCallback& callback,
     const google_apis::GDataErrorCode error,
     SyncStatusCode status) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   if (status == SYNC_STATUS_OK) {
     remote_change_handler()->RemoveChangeForURL(url_);
     status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   }
   callback.Run(status);
 }
 
 void LocalChangeProcessorDelegate::UpdateMetadata(
     const std::string& resource_id,
     const std::string& md5,
     DriveMetadata::ResourceType type,
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   drive_metadata_.set_resource_id(resource_id);
   drive_metadata_.set_md5_checksum(md5);
   drive_metadata_.set_conflicted(false);
   drive_metadata_.set_to_be_fetched(false);
   drive_metadata_.set_type(type);
   metadata_store()->UpdateEntry(url_, drive_metadata_, callback);
 }
 
 void LocalChangeProcessorDelegate::ResetMetadataMD5(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   drive_metadata_.set_md5_checksum(std::string());
   metadata_store()->UpdateEntry(url_, drive_metadata_, callback);
 }
 
 void LocalChangeProcessorDelegate::SetMetadataToBeFetched(
     DriveMetadata::ResourceType type,
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   drive_metadata_.set_md5_checksum(std::string());
   drive_metadata_.set_conflicted(false);
   drive_metadata_.set_to_be_fetched(true);
   drive_metadata_.set_type(type);
   metadata_store()->UpdateEntry(url_, drive_metadata_, callback);
 }
 
 void LocalChangeProcessorDelegate::SetMetadataConflict(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   drive_metadata_.set_conflicted(true);
   drive_metadata_.set_to_be_fetched(false);
   metadata_store()->UpdateEntry(url_, drive_metadata_, callback);
 }
 
 void LocalChangeProcessorDelegate::DeleteMetadata(
     const SyncStatusCallback& callback) {
   metadata_store()->DeleteEntry(url_, callback);
 }
 
 void LocalChangeProcessorDelegate::HandleCreationConflict(
     const std::string& resource_id,
     DriveMetadata::ResourceType type,
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   // File-file conflict is found.
   // Populates a fake drive_metadata and set has_drive_metadata = true.
   // In HandleConflictLocalSync:
   // - If conflict_resolution is manual, we'll change conflicted to true
   //   and save the metadata.
   // - Otherwise we'll save the metadata with empty md5 and will start
   //   over local sync as UploadExistingFile.
   drive_metadata_.set_resource_id(resource_id);
   drive_metadata_.set_md5_checksum(std::string());
   drive_metadata_.set_conflicted(false);
   drive_metadata_.set_to_be_fetched(false);
   drive_metadata_.set_type(type);
   has_drive_metadata_ = true;
   HandleConflict(callback);
 }
 
 void LocalChangeProcessorDelegate::HandleConflict(
     const SyncStatusCallback& callback) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   DCHECK(!drive_metadata_.resource_id().empty());
   api_util()->GetResourceEntry(
       drive_metadata_.resource_id(),
       base::Bind(
           &LocalChangeProcessorDelegate::DidGetEntryForConflictResolution,
           weak_factory_.GetWeakPtr(), callback));
 }
 
 void LocalChangeProcessorDelegate::DidGetEntryForConflictResolution(
     const SyncStatusCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::ResourceEntry> entry) {
-  if (!sync_service_)
+  if (!sync_service_.get())
     return;
 
   SyncFileType local_file_type = local_metadata_.file_type;
   base::Time local_modification_time = local_metadata_.last_modified;
 
   SyncFileType remote_file_type;
   base::Time remote_modification_time = entry->updated_time();
   if (entry->is_file())
     remote_file_type = SYNC_FILE_TYPE_FILE;
   else if (entry->is_folder())
@@ skipping 79 matching lines @@
 APIUtilInterface* LocalChangeProcessorDelegate::api_util() {
   return sync_service_->api_util_.get();
 }
 
 RemoteChangeHandler* LocalChangeProcessorDelegate::remote_change_handler() {
   return &sync_service_->remote_change_handler_;
 }
 
 }  // namespace drive
 }  // namespace sync_file_system