gdata: Fix a bug where |root_| was accessed without a lock

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 <errno.h>
 #include <sys/stat.h>
 
 #include <set>
@@ skipping 1041 matching lines @@
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::AutoLock lock(lock_);
   if (root_->origin() == INITIALIZING) {
     // If root feed is not initialized but the initilization 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::FindEntryByPathOnCallingThread,
+        base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                    ui_weak_ptr_,
                    search_file_path,
                    callback)));
     return;
   } else if (root_->origin() == UNINITIALIZED) {
     // Load root feed from this disk cache. Upon completion, kick off server
     // fetching.
     root_->set_origin(INITIALIZING);
     LoadRootFeedFromCache(true,  // should_load_from_server
                           search_file_path,
                           callback);
     return;
   } else if (root_->NeedsRefresh()) {
     // If content is stale or from disk from cache, fetch content from
     // the server.
     ContentOrigin initial_origin = root_->origin();
     root_->set_origin(REFRESHING);
     ReloadFeedFromServerIfNeeded(initial_origin,
                                  root_->largest_changestamp(),
                                  search_file_path,
                                  callback);
     return;
   }
 
   // Post a task to the same thread, rather than calling it here, as
   // FindEntryByPathAsync() is asynchronous.
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
-      base::Bind(&GDataFileSystem::FindEntryByPathOnCallingThread,
+      base::Bind(&GDataFileSystem::FindEntryByPathSyncOnUIThread,
                  ui_weak_ptr_,
                  search_file_path,
                  callback));
 }
 
-void GDataFileSystem::FindEntryByPathOnCallingThread(
+void GDataFileSystem::FindEntryByPathSyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  base::AutoLock lock(lock_);  // To access root_.
   FindEntryCallbackRelayDelegate delegate(callback);
   root_->FindEntryByPath(search_file_path, &delegate);
 }
 
 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,
                  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));
+
   base::PlatformFileError error = GDataToPlatformError(status);
   if (error != base::PLATFORM_FILE_OK) {
     // Get changes starting from the next changestamp from what we have locally.
     LoadFeedFromServer(local_changestamp + 1, 0, search_file_path, callback);
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> feed;
   if (feed_data.get())
       feed = AccountMetadataFeed::CreateFrom(*feed_data);
@@ skipping 14 matching lines @@
       base::AutoLock lock(lock_);
       root_->set_origin(initial_origin);
       root_->set_refresh_time(base::Time::Now());
     }
     changes_detected = false;
   }
 
   // No changes detected, continue with search as planned.
   if (!changes_detected) {
     if (!callback.is_null())
-      FindEntryByPathOnCallingThread(search_file_path, callback);
+      FindEntryByPathSyncOnUIThread(search_file_path, callback);
 
     NotifyInitialLoadFinished();
     return;
   }
 
   SaveFeed(feed_data.Pass(), FilePath(kAccountMetadataFile));
 
   // Load changes from the server.
   LoadFeedFromServer(local_changestamp > 0 ? local_changestamp + 1 : 0,
                      feed->largest_changestamp(),
@@ skipping 1510 matching lines @@
 
     return;
   }
 
   // Save file system metadata to disk.
   SaveFileSystemAsProto();
 
   // If we had someone to report this too, then this retrieval was done in a
   // context of search... so continue search.
   if (!params->callback.is_null()) {
-    FindEntryByPathOnCallingThread(params->search_file_path, params->callback);
+    FindEntryByPathSyncOnUIThread(params->search_file_path, params->callback);
   }
 }
 
 void GDataFileSystem::LoadRootFeedFromCache(
     bool should_load_from_server,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const FilePath path =
       GetCacheDirectoryPath(GDataRootDirectory::CACHE_TYPE_META).Append(
           kFilesystemProtoFile);
   LoadRootFeedParams* params = new LoadRootFeedParams(search_file_path,
                                                       should_load_from_server,
                                                       callback);
   BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
       base::Bind(&LoadProtoOnIOThreadPool, path, params),
       base::Bind(&GDataFileSystem::OnProtoLoaded,
                  ui_weak_ptr_,
                  base::Owned(params)));
 }
 
 void GDataFileSystem::OnProtoLoaded(LoadRootFeedParams* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   {
     base::AutoLock lock(lock_);
     // If we have already received updates from the server, bail out.
     if (root_->origin() == FROM_SERVER)
       return;
   }
   int local_changestamp = 0;
   // Update directory structure only if everything is OK and we haven't yet
   // received the feed from the server yet.
   if (params->load_error == base::PLATFORM_FILE_OK) {
     DVLOG(1) << "ParseFromString";
     base::AutoLock lock(lock_);  // To access root_.
     if (root_->ParseFromString(params->proto)) {
       root_->set_last_serialized(params->last_modified);
       root_->set_serialized_size(params->proto.size());
       NotifyInitialLoadFinished();
       local_changestamp = root_->largest_changestamp();
     } else {
       params->load_error = base::PLATFORM_FILE_ERROR_FAILED;
       LOG(WARNING) << "Parse of cached proto file failed";
     }
   }
 
   FindEntryCallback callback = params->callback;
   // If we got feed content from cache, try search over it.
   if (!params->should_load_from_server ||
       (params->load_error == base::PLATFORM_FILE_OK && !callback.is_null())) {
     // Continue file content search operation if the delegate hasn't terminated
     // this search branch already.
-    FindEntryByPathOnCallingThread(params->search_file_path, callback);
+    FindEntryByPathSyncOnUIThread(params->search_file_path, callback);
     callback.Reset();
   }
 
   if (!params->should_load_from_server)
     return;
 
   {
     base::AutoLock lock(lock_);
     if (root_->origin() != INITIALIZING)
       root_->set_origin(REFRESHING);
@@ skipping 1957 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata