Replace refcounting with weak pointers for BookmarkStore.

components/bookmarks/browser/bookmark_storage.cc

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_storage.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
@@ skipping 30 matching lines @@
   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));
   }
 }
 
 void LoadCallback(const base::FilePath& path,
-                  BookmarkStorage* storage,
+                  const base::WeakPtr<BookmarkStorage>& storage,
                   BookmarkLoadDetails* details,
                   base::SequencedTaskRunner* task_runner) {
   startup_metric_utils::ScopedSlowStartupUMA
       scoped_timer("Startup.SlowStartupBookmarksLoad");
   bool load_index = false;
   bool bookmark_file_exists = base::PathExists(path);
   if (bookmark_file_exists) {
     JSONFileValueSerializer serializer(path);
     scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
 
@@ skipping 77 matching lines @@
 }
 
 // BookmarkStorage -------------------------------------------------------------
 
 BookmarkStorage::BookmarkStorage(
     BookmarkModel* model,
     const base::FilePath& profile_path,
     base::SequencedTaskRunner* sequenced_task_runner)
     : model_(model),
       writer_(profile_path.Append(bookmarks::kBookmarksFileName),
-              sequenced_task_runner) {
+              sequenced_task_runner),
+      weak_factory_(this) {
   sequenced_task_runner_ = sequenced_task_runner;
   writer_.set_commit_interval(base::TimeDelta::FromMilliseconds(kSaveDelayMS));
   sequenced_task_runner_->PostTask(FROM_HERE,
                                    base::Bind(&BackupCallback, writer_.path()));
 }
 
 BookmarkStorage::~BookmarkStorage() {
   if (writer_.HasPendingWrite())
     writer_.DoScheduledWrite();
 }
 
 void BookmarkStorage::LoadBookmarks(
     scoped_ptr<BookmarkLoadDetails> details,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   DCHECK(!details_.get());
   DCHECK(details);
   details_ = details.Pass();
   sequenced_task_runner_->PostTask(FROM_HERE,
                                    base::Bind(&LoadCallback,
                                               writer_.path(),
-                                              make_scoped_refptr(this),
+                                              weak_factory_.GetWeakPtr(),
                                               details_.get(),
                                               task_runner));
 }
 
 void BookmarkStorage::ScheduleSave() {
   writer_.ScheduleWrite(this);
 }
 
 void BookmarkStorage::BookmarkModelDeleted() {
   // We need to save now as otherwise by the time SaveNow is invoked
@@ skipping 27 matching lines @@
   }
 
   std::string data;
   if (!SerializeData(&data))
     return false;
   writer_.WriteNow(data);
   return true;
 }
 
 }  // namespace bookmarks