Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/bookmarks/bookmark_storage.cc

 // Copyright (c) 2006-2008 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/bookmarks/bookmark_storage.h"
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
-#include "base/message_loop.h"
-#include "base/thread.h"
 #include "base/time.h"
 #include "chrome/browser/bookmarks/bookmark_codec.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
-#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 
 using base::TimeTicks;
 
 namespace {
 
@@ skipping 32 matching lines @@
   const FilePath path_;
 
   DISALLOW_COPY_AND_ASSIGN(FileDeleteTask);
 };
 
 }  // namespace
 
 class BookmarkStorage::LoadTask : public Task {
  public:
   LoadTask(const FilePath& path,
-           MessageLoop* loop,
            BookmarkStorage* storage,
            LoadDetails* details)
       : path_(path),
-        loop_(loop),
         storage_(storage),
         details_(details) {
   }
 
   virtual void Run() {
     bool bookmark_file_exists = file_util::PathExists(path_);
     if (bookmark_file_exists) {
       JSONFileValueSerializer serializer(path_);
       scoped_ptr<Value> root(serializer.Deserialize(NULL));
 
@@ skipping 13 matching lines @@
                             TimeTicks::Now() - start_time);
 
         start_time = TimeTicks::Now();
         AddBookmarksToIndex(details_->bb_node());
         AddBookmarksToIndex(details_->other_folder_node());
         UMA_HISTOGRAM_TIMES("Bookmarks.CreateBookmarkIndexTime",
                             TimeTicks::Now() - start_time);
       }
     }
 
-    if (loop_) {
-      loop_->PostTask(FROM_HERE, NewRunnableMethod(
-          storage_.get(), &BookmarkStorage::OnLoadFinished,
-          bookmark_file_exists, path_));
-    } else {
-      storage_->OnLoadFinished(bookmark_file_exists, path_);
-    }
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            storage_.get(), &BookmarkStorage::OnLoadFinished,
+            bookmark_file_exists, path_));
   }
 
  private:
   // Adds node to the model's index, recursing through all children as well.
   void AddBookmarksToIndex(BookmarkNode* node) {
     if (node->is_url()) {
       if (node->GetURL().is_valid())
         details_->index()->Add(node);
     } else {
       for (int i = 0; i < node->GetChildCount(); ++i)
         AddBookmarksToIndex(node->GetChild(i));
     }
   }
 
   const FilePath path_;
-  MessageLoop* loop_;
   scoped_refptr<BookmarkStorage> storage_;
   LoadDetails* details_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadTask);
 };
 
 // BookmarkStorage -------------------------------------------------------------
 
 BookmarkStorage::BookmarkStorage(Profile* profile, BookmarkModel* model)
     : profile_(profile),
       model_(model),
-      backend_thread_(g_browser_process->file_thread()),
-      writer_(profile->GetPath().Append(chrome::kBookmarksFileName),
-              backend_thread_),
+      writer_(profile->GetPath().Append(chrome::kBookmarksFileName)),
       tmp_history_path_(
           profile->GetPath().Append(chrome::kHistoryBookmarksFileName)) {
   writer_.set_commit_interval(base::TimeDelta::FromMilliseconds(kSaveDelayMS));
-  RunTaskOnBackendThread(new BackupTask(writer_.path()));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE, new BackupTask(writer_.path()));
 }
 
 BookmarkStorage::~BookmarkStorage() {
   if (writer_.HasPendingWrite())
     writer_.DoScheduledWrite();
 }
 
 void BookmarkStorage::LoadBookmarks(LoadDetails* details) {
   DCHECK(!details_.get());
   DCHECK(details);
   details_.reset(details);
   DoLoadBookmarks(writer_.path());
 }
 
 void BookmarkStorage::DoLoadBookmarks(const FilePath& path) {
-  Task* task = new LoadTask(path,
-                            backend_thread() ? MessageLoop::current() : NULL,
-                            this,
-                            details_.get());
-  RunTaskOnBackendThread(task);
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE, new LoadTask(path, this, details_.get()));
 }
 
 void BookmarkStorage::MigrateFromHistory() {
   // We need to wait until history has finished loading before reading
   // from generated bookmarks file.
   HistoryService* history =
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   if (!history) {
     // This happens in unit tests.
     if (model_)
@@ skipping 54 matching lines @@
     return;
 
   model_->DoneLoading(details_.release());
 
   if (path == tmp_history_path_) {
     // We just finished migration from history. Save now to new file,
     // after the model is created and done loading.
     SaveNow();
 
     // Clean up after migration from history.
-    RunTaskOnBackendThread(new FileDeleteTask(tmp_history_path_));
+    ChromeThread::PostTask(
+        ChromeThread::FILE, FROM_HERE, new FileDeleteTask(tmp_history_path_));
   }
 }
 
 void BookmarkStorage::Observe(NotificationType type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::HISTORY_LOADED:
       OnHistoryFinishedWriting();
       break;
@@ skipping 11 matching lines @@
     NOTREACHED();
     return false;
   }
 
   std::string data;
   if (!SerializeData(&data))
     return false;
   writer_.WriteNow(data);
   return true;
 }
-
-void BookmarkStorage::RunTaskOnBackendThread(Task* task) const {
-  if (backend_thread()) {
-    backend_thread()->message_loop()->PostTask(FROM_HERE, task);
-  } else {
-    task->Run();
-    delete task;
-  }
-}