base::Bind: Convert chrome/browser/bookmarks.

BUG=none
TEST=none

R=groby@chromium.org

Review URL: http://codereview.chromium.org/8727023

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@111878 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 75 insertions, 103 deletions

diff --git a/chrome/browser/bookmarks/bookmark_html_writer.cc b/chrome/browser/bookmarks/bookmark_html_writer.cc
index 6f4fde7..73103c0 100644
--- a/chrome/browser/bookmarks/bookmark_html_writer.cc
+++ b/chrome/browser/bookmarks/bookmark_html_writer.cc
@@ -9,6 +9,7 @@
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_path.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
@@ -83,9 +84,9 @@ const char kFolderChildrenEnd[] = "</DL><p>";
 const size_t kIndentSize = 4;
 
 // Class responsible for the actual writing. Takes ownership of favicons_map.
-class Writer : public Task {
+class Writer : public base::RefCountedThreadSafe<Writer> {
  public:
-  Writer(Value* bookmarks,
+  Writer(base::Value* bookmarks,
          const FilePath& path,
          BookmarkFaviconFetcher::URLFaviconMap* favicons_map,
          BookmarksExportObserver* observer)
@@ -95,16 +96,10 @@ class Writer : public Task {
         observer_(observer) {
   }
 
-  virtual void Run() {
-    RunImpl();
-    NotifyOnFinish();
-  }
-
   // Writing bookmarks and favicons data to file.
-  virtual void RunImpl() {
-    if (!OpenFile()) {
+  void DoWrite() {
+    if (!OpenFile())
       return;
-    }
 
     Value* roots;
     if (!Write(kHeader) ||
@@ -150,6 +145,8 @@ class Writer : public Task {
     Write(kNewline);
     // File stream close is forced so that unit test could read it.
     file_stream_.Close();
+
+    NotifyOnFinish();
   }
 
  private:
@@ -374,6 +371,8 @@ class Writer : public Task {
   // How much we indent when writing a bookmark/folder. This is modified
   // via IncrementIndent and DecrementIndent.
   std::string indent_;
+
+  DISALLOW_COPY_AND_ASSIGN(Writer);
 };
 
 }  // namespace
@@ -430,11 +429,11 @@ void BookmarkFaviconFetcher::ExecuteWriter() {
   // for the duration of the write), as such we make a copy of the
   // BookmarkModel using BookmarkCodec then write from that.
   BookmarkCodec codec;
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      new Writer(codec.Encode(profile_->GetBookmarkModel()),
-                 path_,
-                 favicons_map_.release(),
-                 observer_));
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&Writer::DoWrite,
+                 new Writer(codec.Encode(profile_->GetBookmarkModel()),
+                            path_, favicons_map_.release(), observer_)));
   if (fetcher != NULL) {
     MessageLoop::current()->DeleteSoon(FROM_HERE, fetcher);
     fetcher = NULL;
diff --git a/chrome/browser/bookmarks/bookmark_storage.cc b/chrome/browser/bookmarks/bookmark_storage.cc
index bcae88a..58881cf 100644
--- a/chrome/browser/bookmarks/bookmark_storage.cc
+++ b/chrome/browser/bookmarks/bookmark_storage.cc
@@ -30,89 +30,62 @@ const FilePath::CharType kBackupExtension[] = FILE_PATH_LITERAL("bak");
 // How often we save.
 const int kSaveDelayMS = 2500;
 
-class BackupTask : public Task {
- public:
-  explicit BackupTask(const FilePath& path) : path_(path) {
-  }
-
-  virtual void Run() {
-    FilePath backup_path = path_.ReplaceExtension(kBackupExtension);
-    file_util::CopyFile(path_, backup_path);
-  }
-
- private:
-  const FilePath path_;
-
-  DISALLOW_COPY_AND_ASSIGN(BackupTask);
-};
-
-}  // namespace
-
-class BookmarkStorage::LoadTask : public Task {
- public:
-  LoadTask(const FilePath& path,
-           BookmarkStorage* storage,
-           BookmarkLoadDetails* details)
-      : path_(path),
-        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, NULL));
-
-      if (root.get()) {
-        // Building the index can take a while, so we do it on the background
-        // thread.
-        int64 max_node_id = 0;
-        BookmarkCodec codec;
-        TimeTicks start_time = TimeTicks::Now();
-        codec.Decode(details_->bb_node(), details_->other_folder_node(),
-                     details_->synced_folder_node(), &max_node_id, *root.get());
-        details_->set_max_id(std::max(max_node_id, details_->max_id()));
-        details_->set_computed_checksum(codec.computed_checksum());
-        details_->set_stored_checksum(codec.stored_checksum());
-        details_->set_ids_reassigned(codec.ids_reassigned());
-        UMA_HISTOGRAM_TIMES("Bookmarks.DecodeTime",
-                            TimeTicks::Now() - start_time);
-
-        start_time = TimeTicks::Now();
-        AddBookmarksToIndex(details_->bb_node());
-        AddBookmarksToIndex(details_->other_folder_node());
-        AddBookmarksToIndex(details_->synced_folder_node());
-        UMA_HISTOGRAM_TIMES("Bookmarks.CreateBookmarkIndexTime",
-                            TimeTicks::Now() - start_time);
-      }
-    }
+void BackupCallback(const FilePath& path) {
+  FilePath backup_path = path.ReplaceExtension(kBackupExtension);
+  file_util::CopyFile(path, backup_path);
+}
 
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(
-            &BookmarkStorage::OnLoadFinished, storage_.get(),
-            bookmark_file_exists, path_));
+// Adds node to the model's index, recursing through all children as well.
+void AddBookmarksToIndex(BookmarkLoadDetails* details,
+                         BookmarkNode* node) {
+  if (node->is_url()) {
+    if (node->url().is_valid())
+      details->index()->Add(node);
+  } else {
+    for (int i = 0; i < node->child_count(); ++i)
+      AddBookmarksToIndex(details, node->GetChild(i));
   }
+}
 
- private:
-  // Adds node to the model's index, recursing through all children as well.
-  void AddBookmarksToIndex(BookmarkNode* node) {
-    if (node->is_url()) {
-      if (node->url().is_valid())
-        details_->index()->Add(node);
-    } else {
-      for (int i = 0; i < node->child_count(); ++i)
-        AddBookmarksToIndex(node->GetChild(i));
+void LoadCallback(const FilePath& path,
+                  BookmarkStorage* storage,
+                  BookmarkLoadDetails* details) {
+  bool bookmark_file_exists = file_util::PathExists(path);
+  if (bookmark_file_exists) {
+    JSONFileValueSerializer serializer(path);
+    scoped_ptr<Value> root(serializer.Deserialize(NULL, NULL));
+
+    if (root.get()) {
+      // Building the index can take a while, so we do it on the background
+      // thread.
+      int64 max_node_id = 0;
+      BookmarkCodec codec;
+      TimeTicks start_time = TimeTicks::Now();
+      codec.Decode(details->bb_node(), details->other_folder_node(),
+                   details->synced_folder_node(), &max_node_id, *root.get());
+      details->set_max_id(std::max(max_node_id, details->max_id()));
+      details->set_computed_checksum(codec.computed_checksum());
+      details->set_stored_checksum(codec.stored_checksum());
+      details->set_ids_reassigned(codec.ids_reassigned());
+      UMA_HISTOGRAM_TIMES("Bookmarks.DecodeTime",
+                          TimeTicks::Now() - start_time);
+
+      start_time = TimeTicks::Now();
+      AddBookmarksToIndex(details, details->bb_node());
+      AddBookmarksToIndex(details, details->other_folder_node());
+      AddBookmarksToIndex(details, details->synced_folder_node());
+      UMA_HISTOGRAM_TIMES("Bookmarks.CreateBookmarkIndexTime",
+                          TimeTicks::Now() - start_time);
     }
   }
 
-  const FilePath path_;
-  scoped_refptr<BookmarkStorage> storage_;
-  BookmarkLoadDetails* details_;
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&BookmarkStorage::OnLoadFinished, storage,
+                 bookmark_file_exists, path));
+}
 
-  DISALLOW_COPY_AND_ASSIGN(LoadTask);
-};
+}  // namespace
 
 // BookmarkLoadDetails ---------------------------------------------------------
 
@@ -142,8 +115,8 @@ BookmarkStorage::BookmarkStorage(Profile* profile, BookmarkModel* model)
       tmp_history_path_(
           profile->GetPath().Append(chrome::kHistoryBookmarksFileName)) {
   writer_.set_commit_interval(base::TimeDelta::FromMilliseconds(kSaveDelayMS));
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE, new BackupTask(writer_.path()));
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                          base::Bind(&BackupCallback, writer_.path()));
 }
 
 BookmarkStorage::~BookmarkStorage() {
@@ -160,7 +133,9 @@ void BookmarkStorage::LoadBookmarks(BookmarkLoadDetails* details) {
 
 void BookmarkStorage::DoLoadBookmarks(const FilePath& path) {
   BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE, new LoadTask(path, this, details_.get()));
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&LoadCallback, path, make_scoped_refptr(this),
+                 details_.get()));
 }
 
 void BookmarkStorage::MigrateFromHistory() {
diff --git a/chrome/browser/bookmarks/bookmark_storage.h b/chrome/browser/bookmarks/bookmark_storage.h
index fb61e4a..5314726 100644
--- a/chrome/browser/bookmarks/bookmark_storage.h
+++ b/chrome/browser/bookmarks/bookmark_storage.h
@@ -107,7 +107,13 @@ class BookmarkStorage : public content::NotificationObserver,
   // a pending save, it is saved immediately.
   void BookmarkModelDeleted();
 
-  // ImportantFileWriter::DataSerializer
+  // Callback from backend with the results of the bookmark file. This may be
+  // called multiple times, with different paths. This happens when we migrate
+  // bookmark data from database.
+  void OnLoadFinished(bool file_exists,
+                      const FilePath& path);
+
+  // ImportantFileWriter::DataSerializer implementation.
   virtual bool SerializeData(std::string* output) OVERRIDE;
 
  private:
@@ -115,14 +121,6 @@ class BookmarkStorage : public content::NotificationObserver,
 
   virtual ~BookmarkStorage();
 
-  class LoadTask;
-
-  // Callback from backend with the results of the bookmark file.
-  // This may be called multiple times, with different paths. This happens when
-  // we migrate bookmark data from database.
-  void OnLoadFinished(bool file_exists,
-                      const FilePath& path);
-
   // Loads bookmark data from |file| and notifies the model when finished.
   void DoLoadBookmarks(const FilePath& file);