Revert 149576 - gdata: Make WeakPtrFactory the last parameter

chrome/browser/chromeos/gdata/gdata_file_system.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/chromeos/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 717 matching lines @@
     GDataUploaderInterface* uploader,
     DriveWebAppsRegistryInterface* webapps_registry,
     base::SequencedTaskRunner* blocking_task_runner)
     : profile_(profile),
       cache_(cache),
       uploader_(uploader),
       documents_service_(documents_service),
       webapps_registry_(webapps_registry),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
       hide_hosted_docs_(false),
-      blocking_task_runner_(blocking_task_runner),
-      weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+      ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
+      ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()),
+      blocking_task_runner_(blocking_task_runner) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->Initialize(profile_);
 
   directory_service_.reset(new GDataDirectoryService);
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
 
 void GDataFileSystem::CheckForUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ContentOrigin initial_origin = directory_service_->origin();
   if (initial_origin == FROM_SERVER) {
     directory_service_->set_origin(REFRESHING);
     ReloadFeedFromServerIfNeeded(
         initial_origin,
         directory_service_->largest_changestamp(),
         directory_service_->root()->GetFilePath(),
         base::Bind(&GDataFileSystem::OnUpdateChecked,
-                   weak_ptr_factory_.GetWeakPtr(),
+                   ui_weak_ptr_,
                    initial_origin));
   }
 }
 
 void GDataFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
                                       GDataFileError error,
                                       GDataEntry* /* entry */) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
@@ skipping 21 matching lines @@
 }
 
 void GDataFileSystem::StartUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!update_timer_.IsRunning());
   update_timer_.Start(FROM_HERE,
                       base::TimeDelta::FromSeconds(
                           kGDataUpdateCheckIntervalInSec),
                       base::Bind(&GDataFileSystem::CheckForUpdates,
-                                 weak_ptr_factory_.GetWeakPtr()));
+                          ui_weak_ptr_));
 }
 
 void GDataFileSystem::StopUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(update_timer_.IsRunning());
   update_timer_.Stop();
 }
 
 void GDataFileSystem::GetEntryInfoByResourceId(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetEntryInfoByResourceIdOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::GetEntryInfoByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   directory_service_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::GetEntryInfoByEntryOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByEntryOnUIThread(
     const GetEntryInfoWithFilePathCallback& callback,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (entry) {
     scoped_ptr<GDataEntryProto> entry_proto(new GDataEntryProto);
@@ skipping 14 matching lines @@
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (directory_service_->origin() == INITIALIZING) {
     // If root feed is not initialized but the initialization process has
     // already started, add an observer to execute the remaining task after
     // the end of the initialization.
     AddObserver(new InitialLoadObserver(
         this,
         base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
-                   weak_ptr_factory_.GetWeakPtr(),
+                   ui_weak_ptr_,
                    search_file_path,
                    callback)));
     return;
   } else if (directory_service_->origin() == UNINITIALIZED) {
     // Load root feed from this disk cache. Upon completion, kick off server
     // fetching.
     directory_service_->set_origin(INITIALIZING);
     LoadRootFeedFromCache(
         true,  // should_load_from_server
         search_file_path,
         // This is the initial load, hence we'll notify when it's done.
         base::Bind(&GDataFileSystem::RunAndNotifyInitialLoadFinished,
-                   weak_ptr_factory_.GetWeakPtr(),
+                   ui_weak_ptr_,
                    callback));
     return;
   }
 
   // Post a task to the same thread, rather than calling it here, as
   // FindEntryByPath() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  search_file_path,
                  callback));
 }
 
 void GDataFileSystem::FindEntryByPathSyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataEntry* entry = directory_service_->FindEntryByPathSync(
       search_file_path);
   callback.Run(entry ? GDATA_FILE_OK : GDATA_FILE_ERROR_NOT_FOUND, entry);
 }
 
 void GDataFileSystem::ReloadFeedFromServerIfNeeded(
     ContentOrigin initial_origin,
     int local_changestamp,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // First fetch the latest changestamp to see if there were any new changes
   // there at all.
   documents_service_->GetAccountMetadata(
       base::Bind(&GDataFileSystem::OnGetAccountMetadata,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  initial_origin,
                  local_changestamp,
                  search_file_path,
                  callback));
 }
 
 void GDataFileSystem::OnGetAccountMetadata(
     ContentOrigin initial_origin,
     int local_changestamp,
     const FilePath& search_file_path,
     const FindEntryCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> feed_data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFeedFromServer(initial_origin,
                        local_changestamp + 1, 0,
                        true,  /* should_fetch_multiple_feeds */
                        search_file_path,
                        std::string() /* no search query */,
                        std::string() /* no directory resource ID */,
                        callback,
                        base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
-                                  weak_ptr_factory_.GetWeakPtr()));
+                                  ui_weak_ptr_));
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> account_metadata;
   if (feed_data.get()) {
     account_metadata = AccountMetadataFeed::CreateFrom(*feed_data);
 #ifndef NDEBUG
     // Save account metadata feed for analysis.
     const FilePath path =
         cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
             kAccountMetadataFile);
     PostBlockingPoolSequencedTask(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&SaveFeedOnBlockingPoolForDebugging,
                    path, base::Passed(&feed_data)));
 #endif
   }
 
   if (!account_metadata.get()) {
     LoadFeedFromServer(initial_origin,
                        local_changestamp + 1, 0,
                        true,  /* should_fetch_multiple_feeds */
                        search_file_path,
                        std::string() /* no search query */,
                        std::string() /* no directory resource ID */,
                        callback,
                        base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
-                                  weak_ptr_factory_.GetWeakPtr()));
+                                  ui_weak_ptr_));
     return;
   }
 
   webapps_registry_->UpdateFromFeed(account_metadata.get());
 
   bool changes_detected = true;
   if (local_changestamp >= account_metadata->largest_changestamp()) {
     if (local_changestamp > account_metadata->largest_changestamp()) {
       LOG(WARNING) << "Cached client feed is fresher than server, client = "
                    << local_changestamp
@@ skipping 17 matching lines @@
   // Load changes from the server.
   LoadFeedFromServer(initial_origin,
                      local_changestamp > 0 ? local_changestamp + 1 : 0,
                      account_metadata->largest_changestamp(),
                      true,  /* should_fetch_multiple_feeds */
                      search_file_path,
                      std::string() /* no search query */,
                      std::string() /* no directory resource ID */,
                      callback,
                      base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
-                                weak_ptr_factory_.GetWeakPtr()));
+                                ui_weak_ptr_));
 }
 
 void GDataFileSystem::LoadFeedFromServer(
     ContentOrigin initial_origin,
     int start_changestamp,
     int root_feed_changestamp,
     bool should_fetch_multiple_feeds,
     const FilePath& search_file_path,
     const std::string& search_query,
     const std::string& directory_resource_id,
     const FindEntryCallback& entry_found_callback,
     const LoadDocumentFeedCallback& feed_load_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // |feed_list| will contain the list of all collected feed updates that
   // we will receive through calls of DocumentsService::GetDocuments().
   scoped_ptr<std::vector<DocumentFeed*> > feed_list(
       new std::vector<DocumentFeed*>);
   const base::TimeTicks start_time = base::TimeTicks::Now();
   documents_service_->GetDocuments(
       GURL(),   // root feed start.
       start_changestamp,
       search_query,
       directory_resource_id,
       base::Bind(&GDataFileSystem::OnGetDocuments,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  initial_origin,
                  feed_load_callback,
                  base::Owned(new GetDocumentsParams(start_changestamp,
                                                     root_feed_changestamp,
                                                     feed_list.release(),
                                                     should_fetch_multiple_feeds,
                                                     search_file_path,
                                                     search_query,
                                                     directory_resource_id,
                                                     entry_found_callback)),
@@ skipping 33 matching lines @@
 }
 
 void GDataFileSystem::TransferFileFromRemoteToLocal(
     const FilePath& remote_src_file_path,
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetFileByPath(remote_src_file_path,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForTransferFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  local_dest_file_path,
                  callback),
       GetDownloadDataCallback());
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemote(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure the destination directory exists.
   GetEntryInfoByPath(
       remote_dest_file_path.DirName(),
       base::Bind(
           &GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo,
-          weak_ptr_factory_.GetWeakPtr(),
+          ui_weak_ptr_,
           local_src_file_path,
           remote_dest_file_path,
           callback));
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
@@ skipping 19 matching lines @@
   }
 
   std::string* resource_id = new std::string;
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetDocumentResourceIdOnBlockingPool,
                  local_src_file_path,
                  resource_id),
       base::Bind(&GDataFileSystem::TransferFileForResourceId,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  local_src_file_path,
                  remote_dest_file_path,
                  callback,
                  base::Owned(resource_id)));
 }
 
 void GDataFileSystem::TransferFileForResourceId(
     const FilePath& local_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
@@ skipping 30 matching lines @@
   std::string* content_type = new std::string;
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileInfoOnBlockingPool,
                  local_file_path,
                  error,
                  file_size,
                  content_type),
       base::Bind(&GDataFileSystem::StartFileUploadOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  StartFileUploadParams(local_file_path,
                                        remote_dest_file_path,
                                        callback),
                  base::Owned(error),
                  base::Owned(file_size),
                  base::Owned(content_type)));
 }
 
 void GDataFileSystem::StartFileUploadOnUIThread(
     const StartFileUploadParams& params,
@@ skipping 12 matching lines @@
       params.callback.Run(*error);
 
     return;
   }
 
   // Make sure the destination directory exists.
   GetEntryInfoByPath(
       params.remote_file_path.DirName(),
       base::Bind(
           &GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo,
-          weak_ptr_factory_.GetWeakPtr(),
+          ui_weak_ptr_,
           params,
           *file_size,
           *content_type));
 }
 
 void GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo(
     const StartFileUploadParams& params,
     int64 file_size,
     std::string content_type,
     GDataFileError error,
@@ skipping 17 matching lines @@
   upload_file_info->gdata_path = params.remote_file_path;
   // Use the file name as the title.
   upload_file_info->title = params.remote_file_path.BaseName().value();
   upload_file_info->content_length = file_size;
   upload_file_info->all_bytes_present = true;
   upload_file_info->content_type = content_type;
   upload_file_info->initial_upload_location = GURL(entry_proto->upload_url());
 
   upload_file_info->completion_callback =
       base::Bind(&GDataFileSystem::OnTransferCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  params.callback);
 
   uploader_->UploadNewFile(upload_file_info.Pass());
 }
 
 void GDataFileSystem::OnTransferCompleted(
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 10 matching lines @@
     callback.Run(error);
   }
 }
 
 void GDataFileSystem::Copy(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::CopyOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                src_file_path,
                                dest_file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::CopyOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 35 matching lines @@
                             // in the document title.
                             dest_file_path.BaseName().RemoveExtension().value(),
                             callback);
     return;
   }
 
   // TODO(benchan): Reimplement this once the server API supports
   // copying of regular files directly on the server side.
   GetFileByPath(src_file_path,
                 base::Bind(&GDataFileSystem::OnGetFileCompleteForCopy,
-                           weak_ptr_factory_.GetWeakPtr(),
+                           ui_weak_ptr_,
                            dest_file_path,
                            callback),
                 GetDownloadDataCallback());
 }
 
 void GDataFileSystem::OnGetFileCompleteForCopy(
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     const FilePath& local_file_path,
@@ skipping 12 matching lines @@
   // on the same thread as Copy (IO thread). As TransferRegularFile must run
   // on the UI thread, we thus need to post a task to the UI thread.
   // Also, upon the completion of TransferRegularFile, we need to run |callback|
   // on the same thread as Copy (IO thread), and the transition from UI thread
   // to IO thread is handled by OnTransferRegularFileCompleteForCopy.
   DCHECK_EQ(REGULAR_FILE, file_type);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&GDataFileSystem::TransferRegularFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  local_file_path, remote_dest_file_path,
                  base::Bind(OnTransferRegularFileCompleteForCopy,
                             callback,
                             base::MessageLoopProxy::current())));
 }
 
 void GDataFileSystem::OnGetFileCompleteForTransferFile(
     const FilePath& local_dest_file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
@@ skipping 28 matching lines @@
 
 void GDataFileSystem::CopyDocumentToDirectory(
     const FilePath& dir_path,
     const std::string& resource_id,
     const FilePath::StringType& new_name,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->CopyDocument(resource_id, new_name,
       base::Bind(&GDataFileSystem::OnCopyDocumentCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void GDataFileSystem::Rename(const FilePath& file_path,
                              const FilePath::StringType& new_name,
                              const FilePathUpdateCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // It is a no-op if the file is renamed to the same name.
   if (file_path.BaseName().value() == new_name) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(callback, GDATA_FILE_OK, file_path));
     }
     return;
   }
 
   // Get the edit URL of an entry at |file_path|.
   GetEntryInfoByPath(file_path,
                      base::Bind(
                          &GDataFileSystem::RenameAfterGetEntryInfo,
-                         weak_ptr_factory_.GetWeakPtr(),
+                         ui_weak_ptr_,
                          file_path,
                          new_name,
                          callback));
 }
 
 void GDataFileSystem::RenameAfterGetEntryInfo(
     const FilePath& file_path,
     const FilePath::StringType& new_name,
     const FilePathUpdateCallback& callback,
     GDataFileError error,
@@ skipping 17 matching lines @@
     if (new_file.Extension() ==
         entry_proto->file_specific_info().document_extension()) {
       file_name = new_file.RemoveExtension().value();
     }
   }
 
   documents_service_->RenameResource(
       GURL(entry_proto->edit_url()),
       file_name,
       base::Bind(&GDataFileSystem::OnRenameResourceCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  file_name,
                  callback));
 }
 
 void GDataFileSystem::Move(const FilePath& src_file_path,
                            const FilePath& dest_file_path,
                            const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::MoveOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                src_file_path,
                                dest_file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::MoveOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 15 matching lines @@
       MessageLoop::current()->PostTask(FROM_HERE,
                                        base::Bind(callback, error));
     }
     return;
   }
 
   // If the file/directory is moved to the same directory, just rename it.
   if (src_file_path.DirName() == dest_parent_path) {
     FilePathUpdateCallback final_file_path_update_callback =
         base::Bind(&GDataFileSystem::OnFilePathUpdated,
-                   weak_ptr_factory_.GetWeakPtr(),
+                   ui_weak_ptr_,
                    callback);
 
     Rename(src_file_path, dest_file_path.BaseName().value(),
            final_file_path_update_callback);
     return;
   }
 
   // Otherwise, the move operation involves three steps:
   // 1. Renames the file at |src_file_path| to basename(|dest_file_path|)
   //    within the same directory. The rename operation is a no-op if
   //    basename(|src_file_path|) equals to basename(|dest_file_path|).
   // 2. Removes the file from its parent directory (the file is not deleted),
   //    which effectively moves the file to the root directory.
   // 3. Adds the file to the parent directory of |dest_file_path|, which
   //    effectively moves the file from the root directory to the parent
   //    directory of |dest_file_path|.
   FilePathUpdateCallback add_file_to_directory_callback =
       base::Bind(&GDataFileSystem::AddEntryToDirectory,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  dest_file_path.DirName(),
                  callback);
 
   FilePathUpdateCallback remove_file_from_directory_callback =
       base::Bind(&GDataFileSystem::RemoveEntryFromDirectory,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  src_file_path.DirName(),
                  add_file_to_directory_callback);
 
   Rename(src_file_path, dest_file_path.BaseName().value(),
          remove_file_from_directory_callback);
 }
 
 void GDataFileSystem::AddEntryToDirectory(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
@@ skipping 18 matching lines @@
     if (!callback.is_null())
       MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, error));
 
     return;
   }
 
   documents_service_->AddResourceToDirectory(
       dir_entry->content_url(),
       entry->edit_url(),
       base::Bind(&GDataFileSystem::OnAddEntryToDirectoryCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
 void GDataFileSystem::RemoveEntryFromDirectory(
     const FilePath& dir_path,
     const FilePathUpdateCallback& callback,
     GDataFileError error,
     const FilePath& file_path) {
@@ skipping 18 matching lines @@
           base::Bind(callback, error, file_path));
     }
     return;
   }
 
   documents_service_->RemoveResourceFromDirectory(
       dir->content_url(),
       entry->edit_url(),
       entry->resource_id(),
       base::Bind(&GDataFileSystem::OnRemoveEntryFromDirectoryCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback,
                  file_path,
                  dir_path));
 }
 
 void GDataFileSystem::Remove(const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::RemoveOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                file_path,
                                is_recursive,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::RemoveOnUIThread(
     const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Get the edit URL of an entry at |file_path|.
   GetEntryInfoByPath(file_path,
                      base::Bind(
                          &GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo,
-                         weak_ptr_factory_.GetWeakPtr(),
+                         ui_weak_ptr_,
                          file_path,
                          is_recursive,
                          callback));
 }
 
 void GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     bool /* is_recursive */,
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE, base::Bind(callback, error));
     }
     return;
   }
 
   DCHECK(entry_proto.get());
   documents_service_->DeleteDocument(
       GURL(entry_proto->edit_url()),
       base::Bind(&GDataFileSystem::OnRemovedDocument,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback,
                  file_path));
 }
 
 void GDataFileSystem::CreateDirectory(
     const FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::CreateDirectoryOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                directory_path,
                                is_exclusive,
                                is_recursive,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::CreateDirectoryOnUIThread(
     const FilePath& directory_path,
     bool is_exclusive,
     bool is_recursive,
@@ skipping 44 matching lines @@
       MessageLoop::current()->PostTask(FROM_HERE,
            base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
     }
     return;
   }
 
   documents_service_->CreateDirectory(
       last_parent_dir_url,
       first_missing_path.BaseName().value(),
       base::Bind(&GDataFileSystem::OnCreateDirectoryCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  CreateDirectoryParams(
                      first_missing_path,
                      directory_path,
                      is_exclusive,
                      is_recursive,
                      callback)));
 }
 
 void GDataFileSystem::CreateFile(const FilePath& file_path,
                                  bool is_exclusive,
                                  const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::CreateFileOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                file_path,
                                is_exclusive,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::CreateFileOnUIThread(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // First, checks the existence of a file at |file_path|.
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoForCreateFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  is_exclusive,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryInfoForCreateFile(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback,
     GDataFileError result,
@@ skipping 33 matching lines @@
 }
 
 void GDataFileSystem::GetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetDownloadDataCallback& get_download_data_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetFileByPathOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_download_data_callback)));
 }
 
 void GDataFileSystem::GetFileByPathOnUIThread(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetDownloadDataCallback& get_download_data_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_download_data_callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetDownloadDataCallback& get_download_data_callback,
     GDataFileError error,
@@ skipping 69 matching lines @@
   FilePath local_tmp_path = cache_->GetCacheFilePath(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       GDataCache::CACHE_TYPE_TMP,
       GDataCache::CACHED_FILE_FROM_SERVER);
   cache_->GetFileOnUIThread(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       base::Bind(
           &GDataFileSystem::OnGetFileFromCache,
-          weak_ptr_factory_.GetWeakPtr(),
+          ui_weak_ptr_,
           GetFileFromCacheParams(
               file_path,
               local_tmp_path,
               GURL(entry_proto->content_url()),
               entry_proto->resource_id(),
               entry_proto->file_specific_info().file_md5(),
               entry_proto->file_specific_info().content_mime_type(),
               get_file_callback,
               get_download_data_callback)));
 }
 
 void GDataFileSystem::GetFileByResourceId(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
     const GetDownloadDataCallback& get_download_data_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetFileByResourceIdOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_download_data_callback)));
 }
 
 void GDataFileSystem::GetFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
     const GetDownloadDataCallback& get_download_data_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   directory_service_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::GetFileByEntryOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  get_file_callback,
                  get_download_data_callback));
 }
 
 void GDataFileSystem::GetFileByEntryOnUIThread(
     const GetFileCallback& get_file_callback,
     const GetDownloadDataCallback& get_download_data_callback,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 47 matching lines @@
   // content url from there (we want to make sure used content url is not
   // stale).
   //
   // Check if we have enough space, based on the expected file size.
   // - if we don't have enough space, try to free up the disk space
   // - if we still don't have enough space, return "no space" error
   // - if we have enough space, start downloading the file from the server
   documents_service_->GetDocumentEntry(
       resource_id,
       base::Bind(&GDataFileSystem::OnGetDocumentEntry,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  cache_file_path,
                  GetFileFromCacheParams(params.virtual_file_path,
                                         params.local_tmp_path,
                                         params.content_url,
                                         params.resource_id,
                                         params.md5,
                                         params.mime_type,
                                         params.get_file_callback,
                                         params.get_download_data_callback)));
 }
@@ skipping 40 matching lines @@
 
   bool* has_enough_space = new bool(false);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  file_size,
                  has_enough_space),
       base::Bind(&GDataFileSystem::StartDownloadFileIfEnoughSpace,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  params,
                  content_url,
                  cache_file_path,
                  base::Owned(has_enough_space)));
 }
 
 void GDataFileSystem::StartDownloadFileIfEnoughSpace(
     const GetFileFromCacheParams& params,
     const GURL& content_url,
     const FilePath& cache_file_path,
@@ skipping 10 matching lines @@
     }
     return;
   }
 
   // We have enough disk space. Start downloading the file.
   documents_service_->DownloadFile(
       params.virtual_file_path,
       params.local_tmp_path,
       content_url,
       base::Bind(&GDataFileSystem::OnFileDownloaded,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  params),
       params.get_download_data_callback);
 }
 
 void GDataFileSystem::GetEntryInfoByPath(const FilePath& file_path,
                                          const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::GetEntryInfoByPathAsyncOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::GetEntryInfoByPathAsyncOnUIThread(
     const FilePath& file_path,
     const GetEntryInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfo,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryInfo(const GetEntryInfoCallback& callback,
                                     GDataFileError error,
                                     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, scoped_ptr<GDataEntryProto>());
     return;
   }
   DCHECK(entry);
 
   scoped_ptr<GDataEntryProto> entry_proto(new GDataEntryProto);
   entry->ToProtoFull(entry_proto.get());
 
   CheckLocalModificationAndRun(entry_proto.Pass(), callback);
 }
 
 void GDataFileSystem::ReadDirectoryByPath(
     const FilePath& file_path,
     const ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::ReadDirectoryByPathAsyncOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::ReadDirectoryByPathAsyncOnUIThread(
     const FilePath& file_path,
     const ReadDirectoryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnReadDirectory,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnReadDirectory(const ReadDirectoryCallback& callback,
                                       GDataFileError error,
                                       GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
@@ skipping 31 matching lines @@
 
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, hide_hosted_docs_, entries.Pass());
 }
 
 void GDataFileSystem::RequestDirectoryRefresh(const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::RequestDirectoryRefreshOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshOnUIThread(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure the destination directory exists.
   GetEntryInfoByPath(
       file_path,
       base::Bind(
           &GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo,
-          weak_ptr_factory_.GetWeakPtr(),
+          ui_weak_ptr_,
           file_path));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK ||
       !entry_proto->file_info().is_directory()) {
     LOG(ERROR) << "Directory entry not found: " << file_path.value();
     return;
   }
 
   LoadFeedFromServer(directory_service_->origin(),
                      0,  // Not delta feed.
                      0,  // Not used.
                      true,  // multiple feeds
                      file_path,
                      std::string(),  // No search query
                      entry_proto->resource_id(),
                      FindEntryCallback(),  // Not used.
                      base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
-                                weak_ptr_factory_.GetWeakPtr()));
+                                ui_weak_ptr_));
 }
 
 void GDataFileSystem::OnRequestDirectoryRefresh(
     GetDocumentsParams* params,
     GDataFileError error) {
   DCHECK(params);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const FilePath& directory_path = params->search_file_path;
   if (error != GDATA_FILE_OK) {
@@ skipping 12 matching lines @@
       &unused_delta_feed_changestamp,
       &unused_uma_stats);
   if (error != GDATA_FILE_OK) {
     LOG(ERROR) << "Failed to convert feed: " << directory_path.value()
                << ": " << error;
     return;
   }
 
   directory_service_->GetEntryByResourceIdAsync(params->directory_resource_id,
       base::Bind(&GDataFileSystem::RequestDirectoryRefreshByEntry,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  directory_path,
                  params->directory_resource_id,
                  file_map));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshByEntry(
     const FilePath& directory_path,
     const std::string& directory_resource_id,
     const FileResourceIdMap& file_map,
     GDataEntry* directory_entry) {
@@ skipping 25 matching lines @@
   DVLOG(1) << "Directory refreshed: " << directory_path.value();
 }
 
 void GDataFileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::UpdateFileByResourceIdOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::UpdateFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   directory_service_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::UpdateFileByEntryOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::UpdateFileByEntryOnUIThread(
     const FileOperationCallback& callback,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry || !entry->AsGDataFile()) {
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    GDATA_FILE_ERROR_NOT_FOUND));
     return;
   }
   GDataFile* file = entry->AsGDataFile();
 
   cache_->GetFileOnUIThread(
       file->resource_id(),
       file->file_md5(),
       base::Bind(&GDataFileSystem::OnGetFileCompleteForUpdateFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetFileCompleteForUpdateFile(
     const FileOperationCallback& callback,
     GDataFileError error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
   // Gets the size of the cache file. Since the file is locally modified, the
   // file size information stored in GDataEntry is not correct.
   GDataFileError* get_size_error = new GDataFileError(GDATA_FILE_ERROR_FAILED);
   int64* file_size = new int64(-1);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetLocalFileSizeOnBlockingPool,
                  cache_file_path,
                  get_size_error,
                  file_size),
       base::Bind(&GDataFileSystem::OnGetFileSizeCompleteForUpdateFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback,
                  resource_id,
                  md5,
                  cache_file_path,
                  base::Owned(get_size_error),
                  base::Owned(file_size)));
 }
 
 void GDataFileSystem::OnGetFileSizeCompleteForUpdateFile(
     const FileOperationCallback& callback,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& cache_file_path,
     GDataFileError* error,
     int64* file_size) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (*error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(*error);
     return;
   }
 
   directory_service_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry,
-          weak_ptr_factory_.GetWeakPtr(),
+          ui_weak_ptr_,
           callback,
           md5,
           *file_size,
           cache_file_path));
 }
 
 void GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry(
     const FileOperationCallback& callback,
     const std::string& md5,
     int64 file_size,
     const FilePath& cache_file_path,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry || !entry->AsGDataFile()) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
     return;
   }
   GDataFile* file = entry->AsGDataFile();
 
   uploader_->UploadExistingFile(
       file->upload_url(),
       file->GetFilePath(),
       cache_file_path,
       file_size,
       file->content_mime_type(),
       base::Bind(&GDataFileSystem::OnUpdatedFileUploaded,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnUpdatedFileUploaded(
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(upload_file_info.get());
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
   AddUploadedFile(UPLOAD_EXISTING_FILE,
                   upload_file_info->gdata_path.DirName(),
                   upload_file_info->entry.Pass(),
                   upload_file_info->file_path,
                   GDataCache::FILE_OPERATION_MOVE,
                   base::Bind(&OnAddUploadFileCompleted, callback, error));
 }
 
 void GDataFileSystem::GetAvailableSpace(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::GetAvailableSpaceOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::GetAvailableSpaceOnUIThread(
     const GetAvailableSpaceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   documents_service_->GetAccountMetadata(
       base::Bind(&GDataFileSystem::OnGetAvailableSpace,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetAvailableSpace(
     const GetAvailableSpaceCallback& callback,
     GDataErrorCode status,
     scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = GDataToGDataFileError(status);
@@ skipping 109 matching lines @@
     }
 
     // We will need information about result entry to create info for callback.
     // We can't use |entry| anymore, so we have to refetch entry from file
     // system. Also, |entry| doesn't have file path set before |RefreshFile|
     // call, so we can't get file path from there.
     directory_service_->GetEntryByResourceIdAsync(entry_resource_id,
         base::Bind(&AddEntryToSearchResults,
                    results,
                    callback,
-                   base::Bind(&GDataFileSystem::CheckForUpdates,
-                              weak_ptr_factory_.GetWeakPtr()),
+                   base::Bind(&GDataFileSystem::CheckForUpdates, ui_weak_ptr_),
                    error,
                    i+1 == feed->entries().size()));
   }
 }
 
 void GDataFileSystem::Search(const std::string& search_query,
                              const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::SearchAsyncOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                search_query,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::SearchAsyncOnUIThread(
     const std::string& search_query,
     const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   scoped_ptr<std::vector<DocumentFeed*> > feed_list(
       new std::vector<DocumentFeed*>);
 
   ContentOrigin initial_origin = directory_service_->origin();
   LoadFeedFromServer(initial_origin,
                      0, 0,  // We don't use change stamps when fetching search
                             // data; we always fetch the whole result feed.
                      false,  // Stop fetching search results after first feed
                              // chunk to avoid displaying huge number of search
                              // results (especially since we don't cache them).
                      FilePath(),  // Not used.
                      search_query,
                      std::string(),  // No directory resource ID.
                      FindEntryCallback(),  // Not used.
                      base::Bind(&GDataFileSystem::OnSearch,
-                                weak_ptr_factory_.GetWeakPtr(),
-                                callback));
+                                ui_weak_ptr_, callback));
 }
 
 void GDataFileSystem::OnGetDocuments(ContentOrigin initial_origin,
                                      const LoadDocumentFeedCallback& callback,
                                      GetDocumentsParams* params,
                                      base::TimeTicks start_time,
                                      GDataErrorCode status,
                                      scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 57 matching lines @@
   // Check if we need to collect more data to complete the directory list.
   if (params->should_fetch_multiple_feeds && has_next_feed_url &&
       !next_feed_url.is_empty()) {
     // Kick of the remaining part of the feeds.
     documents_service_->GetDocuments(
         next_feed_url,
         params->start_changestamp,
         params->search_query,
         params->directory_resource_id,
         base::Bind(&GDataFileSystem::OnGetDocuments,
-                   weak_ptr_factory_.GetWeakPtr(),
+                   ui_weak_ptr_,
                    initial_origin,
                    callback,
                    base::Owned(
                        new GetDocumentsParams(
                            params->start_changestamp,
                            params->root_feed_changestamp,
                            params->feed_list.release(),
                            params->should_fetch_multiple_feeds,
                            params->search_file_path,
                            params->search_query,
@@ skipping 18 matching lines @@
 
   const FilePath path =
       cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
           kFilesystemProtoFile);
   LoadRootFeedParams* params = new LoadRootFeedParams(search_file_path,
                                                       should_load_from_server,
                                                       callback);
   BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
       base::Bind(&LoadProtoOnBlockingPool, path, params),
       base::Bind(&GDataFileSystem::OnProtoLoaded,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  base::Owned(params)));
 }
 
 void GDataFileSystem::LoadRootFeedFromCacheForTesting() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LoadRootFeedFromCache(
       false,  // should_load_from_server.
       // search_path doesn't matter if FindEntryCallback parameter is null .
       FilePath(),
@@ skipping 209 matching lines @@
     const FilePath& downloaded_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If user cancels download of a pinned-but-not-fetched file, mark file as
   // unpinned so that we do not sync the file again.
   if (status == GDATA_CANCELLED) {
     cache_->GetCacheEntryOnUIThread(
         params.resource_id,
         params.md5,
         base::Bind(&GDataFileSystem::UnpinIfPinned,
-                   weak_ptr_factory_.GetWeakPtr(),
+                   ui_weak_ptr_,
                    params.resource_id,
                    params.md5));
   }
 
   // At this point, the disk can be full or nearly full for several reasons:
   // - The expected file size was incorrect and the file was larger
   // - There was an in-flight download operation and it used up space
   // - The disk became full for some user actions we cannot control
   //   (ex. the user might have downloaded a large file from a regular web site)
   //
   // If we don't have enough space, we return PLATFORM_FILE_ERROR_NO_SPACE,
   // and try to free up space, even if the file was downloaded successfully.
   bool* has_enough_space = new bool(false);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  0,
                  has_enough_space),
       base::Bind(&GDataFileSystem::OnFileDownloadedAndSpaceChecked,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  params,
                  status,
                  content_url,
                  downloaded_file_path,
                  base::Owned(has_enough_space)));
 }
 
 void GDataFileSystem::UnpinIfPinned(
     const std::string& resource_id,
     const std::string& md5,
@@ skipping 20 matching lines @@
   // to wait for this operation to finish since the user can already use the
   // downloaded file.
   if (error == GDATA_FILE_OK) {
     if (*has_enough_space) {
       cache_->StoreOnUIThread(
           params.resource_id,
           params.md5,
           downloaded_file_path,
           GDataCache::FILE_OPERATION_MOVE,
           base::Bind(&GDataFileSystem::OnDownloadStoredToCache,
-                     weak_ptr_factory_.GetWeakPtr()));
+                     ui_weak_ptr_));
     } else {
       // If we don't have enough space, remove the downloaded file, and
       // report "no space" error.
       PostBlockingPoolSequencedTask(
           FROM_HERE,
           blocking_task_runner_,
           base::Bind(base::IgnoreResult(&file_util::Delete),
                      downloaded_file_path,
                      false /* recursive*/));
       error = GDATA_FILE_ERROR_NO_SPACE;
@@ skipping 272 matching lines @@
     const FilePath& file_content_path,
     GDataCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Post a task to the same thread, rather than calling it here, as
   // AddUploadedFile() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&GDataFileSystem::AddUploadedFileOnUIThread,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  upload_mode,
                  virtual_dir_path,
                  base::Passed(&entry),
                  file_content_path,
                  cache_operation,
                  callback));
 }
 
 void GDataFileSystem::AddUploadedFileOnUIThread(
     UploadMode upload_mode,
@@ skipping 105 matching lines @@
   pref_registrar_.reset(new PrefChangeRegistrar());
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void GDataFileSystem::OpenFile(const FilePath& file_path,
                                const OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::OpenFileOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::OpenFileOnUIThread(const FilePath& file_path,
                                          const OpenFileCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If the file is already opened, it cannot be opened again before closed.
   // This is for avoiding simultaneous modification to the file, and moreover
   // to avoid an inconsistent cache state (suppose an operation sequence like
   // Open->Open->modify->Close->modify->Close; the second modify may not be
   // synchronized to the server since it is already Closed on the cache).
   if (open_files_.find(file_path) != open_files_.end()) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_FILE_ERROR_IN_USE, FilePath()));
     return;
   }
   open_files_.insert(file_path);
 
   GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForOpenFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  base::Bind(&GDataFileSystem::OnOpenFileFinished,
-                            weak_ptr_factory_.GetWeakPtr(),
+                            ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForOpenFile(
     const FilePath& file_path,
     const OpenFileCallback& callback,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 12 matching lines @@
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, FilePath());
     return;
   }
 
   DCHECK(!entry_proto->resource_id().empty());
   GetResolvedFileByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForOpenFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback,
                  GetFileCompleteForOpenParams(
                      entry_proto->resource_id(),
                      entry_proto->file_specific_info().file_md5())),
       GetDownloadDataCallback(),
       error,
       entry_proto.get());
 }
 
 void GDataFileSystem::OnGetFileCompleteForOpenFile(
@@ skipping 11 matching lines @@
     return;
   }
 
   // OpenFileOnUIThread ensures that the file is a regular file.
   DCHECK_EQ(REGULAR_FILE, file_type);
 
   cache_->MarkDirtyOnUIThread(
       entry_proto.resource_id,
       entry_proto.md5,
       base::Bind(&GDataFileSystem::OnMarkDirtyInCacheCompleteForOpenFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnMarkDirtyInCacheCompleteForOpenFile(
     const OpenFileCallback& callback,
     GDataFileError error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 16 matching lines @@
 
   if (!callback.is_null())
     callback.Run(result, cache_file_path);
 }
 
 void GDataFileSystem::CloseFile(const FilePath& file_path,
                                 const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::CloseFileOnUIThread,
-                               weak_ptr_factory_.GetWeakPtr(),
+                               ui_weak_ptr_,
                                file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::CloseFileOnUIThread(
     const FilePath& file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (open_files_.find(file_path) == open_files_.end()) {
     // The file is not being opened.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   // Step 1 of CloseFile: Get resource_id and md5 for |file_path|.
   GetEntryInfoByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForCloseFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  base::Bind(&GDataFileSystem::OnCloseFileFinished,
-                            weak_ptr_factory_.GetWeakPtr(),
+                            ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForCloseFile(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   if (entry_proto.get() && !entry_proto->has_file_specific_info())
     error = GDATA_FILE_ERROR_NOT_FOUND;
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
   // Step 2 of CloseFile: Get the local path of the cache. Since CloseFile must
   // always be called on paths opened by OpenFile, the file must be cached,
   cache_->GetFileOnUIThread(
       entry_proto->resource_id(),
       entry_proto->file_specific_info().file_md5(),
       base::Bind(&GDataFileSystem::OnGetCacheFilePathCompleteForCloseFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  callback));
 }
 
 void GDataFileSystem::OnGetCacheFilePathCompleteForCloseFile(
     const FilePath& file_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     const std::string& resource_id,
     const std::string& md5,
@@ skipping 11 matching lines @@
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
   bool* get_file_info_result = new bool(false);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetFileInfoOnBlockingPool,
                  local_cache_path,
                  base::Unretained(file_info),
                  base::Unretained(get_file_info_result)),
       base::Bind(&GDataFileSystem::OnGetModifiedFileInfoCompleteForCloseFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  base::Owned(file_info),
                  base::Owned(get_file_info_result),
                  callback));
 }
 
 void GDataFileSystem::OnGetModifiedFileInfoCompleteForCloseFile(
     const FilePath& file_path,
     base::PlatformFileInfo* file_info,
     bool* get_file_info_result,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!*get_file_info_result) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   // Step 4 of CloseFile: Find GDataEntry corresponding to |file_path|, for
   // modifying the entry's metadata.
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryCompleteForCloseFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  file_path,
                  *file_info,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryCompleteForCloseFile(
     const FilePath& file_path,
     const base::PlatformFileInfo& file_info,
     const FileOperationCallback& callback,
     GDataFileError error,
@@ skipping 26 matching lines @@
   // Step 6 of CloseFile: Commit the modification in cache. This will trigger
   // background upload.
   // TODO(benchan,kinaba): Call ClearDirtyInCache instead of CommitDirtyInCache
   // if the file has not been modified. Come up with a way to detect the
   // intactness effectively, or provide a method for user to declare it when
   // calling CloseFile().
   cache_->CommitDirtyOnUIThread(
       file->resource_id(),
       file->file_md5(),
       base::Bind(&GDataFileSystem::OnCommitDirtyInCacheCompleteForCloseFile,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnCommitDirtyInCacheCompleteForCloseFile(
     const FileOperationCallback& callback,
     GDataFileError error,
     const std::string& resource_id,
     const std::string& md5) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 33 matching lines @@
   }
 
   // Checks if the file is cached and modified locally.
   const std::string resource_id = entry_proto->resource_id();
   const std::string md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetCacheEntryOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry,
-          weak_ptr_factory_.GetWeakPtr(),
-          base::Passed(&entry_proto),
-          callback));
+          ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheEntry(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     bool success,
     const GDataCacheEntry& cache_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // When no dirty cache is found, use the original entry info as is.
   if (!success || !cache_entry.is_dirty()) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // Gets the cache file path.
   const std::string& resource_id = entry_proto->resource_id();
   const std::string& md5 = entry_proto->file_specific_info().file_md5();
   cache_->GetFileOnUIThread(
       resource_id,
       md5,
       base::Bind(
           &GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile,
-          weak_ptr_factory_.GetWeakPtr(),
-          base::Passed(&entry_proto),
-          callback));
+          ui_weak_ptr_, base::Passed(&entry_proto), callback));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetCacheFile(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     GDataFileError error,
     const std::string& resource_id,
     const std::string& md5,
     const FilePath& local_cache_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // When no dirty cache is found, use the original entry info as is.
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_OK, entry_proto.Pass());
     return;
   }
 
   // If the cache is dirty, obtain the file info from the cache file itself.
   base::PlatformFileInfo* file_info = new base::PlatformFileInfo;
   bool* get_file_info_result = new bool(false);
   PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GetFileInfoOnBlockingPool,
                  local_cache_path,
                  base::Unretained(file_info),
                  base::Unretained(get_file_info_result)),
       base::Bind(&GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo,
-                 weak_ptr_factory_.GetWeakPtr(),
+                 ui_weak_ptr_,
                  base::Passed(&entry_proto),
                  callback,
                  base::Owned(file_info),
                  base::Owned(get_file_info_result)));
 }
 
 void GDataFileSystem::CheckLocalModificationAndRunAfterGetFileInfo(
     scoped_ptr<GDataEntryProto> entry_proto,
     const GetEntryInfoCallback& callback,
     base::PlatformFileInfo* file_info,
     bool* get_file_info_result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!*get_file_info_result) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_NOT_FOUND, scoped_ptr<GDataEntryProto>());
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata