Change ownership of BookmarkClient.

BookmarkModel now owns the BookmarkClient (there is no real need for
BookmarkClient to be a KeyedService). As was found in other components
having the client be owned by the service reduce the risk of breaking
the componentization.

BUG=None

Review URL: https://codereview.chromium.org/1586013002

Cr-Commit-Position: refs/heads/master@{#372654}

35 files changed, 114 insertions, 370 deletions

diff --git a/chrome/browser/bookmarks/bookmark_model_factory.cc b/chrome/browser/bookmarks/bookmark_model_factory.cc
index 341829c..36f85f0 100644
--- a/chrome/browser/bookmarks/bookmark_model_factory.cc
+++ b/chrome/browser/bookmarks/bookmark_model_factory.cc
@@ -11,7 +11,7 @@
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
+#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/bookmarks/startup_task_runner_service_factory.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
@@ -56,7 +56,7 @@ BookmarkModelFactory::BookmarkModelFactory()
         "BookmarkModel",
         BrowserContextDependencyManager::GetInstance()) {
   DependsOn(BookmarkUndoServiceFactory::GetInstance());
-  DependsOn(ChromeBookmarkClientFactory::GetInstance());
+  DependsOn(ManagedBookmarkServiceFactory::GetInstance());
   DependsOn(StartupTaskRunnerServiceFactory::GetInstance());
 #if BUILDFLAG(ANDROID_JAVA_UI)
   if (offline_pages::IsOfflinePagesEnabled())
@@ -70,10 +70,9 @@ BookmarkModelFactory::~BookmarkModelFactory() {
 KeyedService* BookmarkModelFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   Profile* profile = Profile::FromBrowserContext(context);
-  ChromeBookmarkClient* bookmark_client =
-      ChromeBookmarkClientFactory::GetForProfile(profile);
-  BookmarkModel* bookmark_model = new BookmarkModel(bookmark_client);
-  bookmark_client->Init(bookmark_model);
+  BookmarkModel* bookmark_model =
+      new BookmarkModel(make_scoped_ptr(new ChromeBookmarkClient(
+          profile, ManagedBookmarkServiceFactory::GetForProfile(profile))));
   bookmark_model->Load(profile->GetPrefs(),
                        profile->GetPrefs()->GetString(prefs::kAcceptLanguages),
                        profile->GetPath(),
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client.cc b/chrome/browser/bookmarks/chrome_bookmark_client.cc
index afe3bc4..8666f81 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client.cc
+++ b/chrome/browser/bookmarks/chrome_bookmark_client.cc
@@ -32,11 +32,6 @@ void ChromeBookmarkClient::Init(bookmarks::BookmarkModel* model) {
     managed_bookmark_service_->BookmarkModelCreated(model);
 }
 
-void ChromeBookmarkClient::Shutdown() {
-  managed_bookmark_service_ = nullptr;
-  BookmarkClient::Shutdown();
-}
-
 bool ChromeBookmarkClient::PreferTouchIcon() {
   return false;
 }
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client.h b/chrome/browser/bookmarks/chrome_bookmark_client.h
index 3fdde2c..621f408 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client.h
+++ b/chrome/browser/bookmarks/chrome_bookmark_client.h
@@ -33,12 +33,8 @@ class ChromeBookmarkClient : public bookmarks::BookmarkClient {
       bookmarks::ManagedBookmarkService* managed_bookmark_service);
   ~ChromeBookmarkClient() override;
 
-  void Init(bookmarks::BookmarkModel* model);
-
-  // KeyedService:
-  void Shutdown() override;
-
   // bookmarks::BookmarkClient:
+  void Init(bookmarks::BookmarkModel* model) override;
   bool PreferTouchIcon() override;
   base::CancelableTaskTracker::TaskId GetFaviconImageForPageURL(
       const GURL& page_url,
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc b/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc
deleted file mode 100644
index c84a374..0000000
--- a/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc
+++ /dev/null
@@ -1,66 +0,0 @@
-// 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 "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
-
-#include "base/memory/singleton.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client.h"
-#include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
-#include "chrome/browser/profiles/incognito_helpers.h"
-#include "chrome/browser/profiles/profile.h"
-#include "components/bookmarks/managed/managed_bookmark_service.h"
-#include "components/keyed_service/content/browser_context_dependency_manager.h"
-
-namespace {
-
-scoped_ptr<KeyedService> BuildChromeBookmarkClient(
-    content::BrowserContext* context) {
-  Profile* profile = Profile::FromBrowserContext(context);
-  return make_scoped_ptr(new ChromeBookmarkClient(
-      profile, ManagedBookmarkServiceFactory::GetForProfile(profile)));
-}
-
-}  // namespace
-
-// static
-ChromeBookmarkClient* ChromeBookmarkClientFactory::GetForProfile(
-    Profile* profile) {
-  return static_cast<ChromeBookmarkClient*>(
-      GetInstance()->GetServiceForBrowserContext(profile, true));
-}
-
-// static
-ChromeBookmarkClientFactory* ChromeBookmarkClientFactory::GetInstance() {
-  return base::Singleton<ChromeBookmarkClientFactory>::get();
-}
-
-// static
-BrowserContextKeyedServiceFactory::TestingFactoryFunction
-ChromeBookmarkClientFactory::GetDefaultFactory() {
-  return &BuildChromeBookmarkClient;
-}
-
-ChromeBookmarkClientFactory::ChromeBookmarkClientFactory()
-    : BrowserContextKeyedServiceFactory(
-          "ChromeBookmarkClient",
-          BrowserContextDependencyManager::GetInstance()) {
-  DependsOn(ManagedBookmarkServiceFactory::GetInstance());
-}
-
-ChromeBookmarkClientFactory::~ChromeBookmarkClientFactory() {
-}
-
-KeyedService* ChromeBookmarkClientFactory::BuildServiceInstanceFor(
-    content::BrowserContext* context) const {
-  return BuildChromeBookmarkClient(context).release();
-}
-
-content::BrowserContext* ChromeBookmarkClientFactory::GetBrowserContextToUse(
-    content::BrowserContext* context) const {
-  return chrome::GetBrowserContextRedirectedInIncognito(context);
-}
-
-bool ChromeBookmarkClientFactory::ServiceIsNULLWhileTesting() const {
-  return true;
-}
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_factory.h b/chrome/browser/bookmarks/chrome_bookmark_client_factory.h
deleted file mode 100644
index 6976098..0000000
--- a/chrome/browser/bookmarks/chrome_bookmark_client_factory.h
+++ /dev/null
@@ -1,43 +0,0 @@
-// 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.
-
-#ifndef CHROME_BROWSER_BOOKMARKS_CHROME_BOOKMARK_CLIENT_FACTORY_H_
-#define CHROME_BROWSER_BOOKMARKS_CHROME_BOOKMARK_CLIENT_FACTORY_H_
-
-#include "base/macros.h"
-#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
-
-namespace base {
-template <typename T>
-struct DefaultSingletonTraits;
-}  // namespace base
-
-class ChromeBookmarkClient;
-class Profile;
-
-// Singleton that owns all ChromeBookmarkClients and associates them with
-// Profiles.
-class ChromeBookmarkClientFactory : public BrowserContextKeyedServiceFactory {
- public:
-  static ChromeBookmarkClient* GetForProfile(Profile* profile);
-  static ChromeBookmarkClientFactory* GetInstance();
-  static TestingFactoryFunction GetDefaultFactory();
-
- private:
-  friend struct base::DefaultSingletonTraits<ChromeBookmarkClientFactory>;
-
-  ChromeBookmarkClientFactory();
-  ~ChromeBookmarkClientFactory() override;
-
-  // BrowserContextKeyedServiceFactory:
-  KeyedService* BuildServiceInstanceFor(
-      content::BrowserContext* context) const override;
-  content::BrowserContext* GetBrowserContextToUse(
-      content::BrowserContext* context) const override;
-  bool ServiceIsNULLWhileTesting() const override;
-
-  DISALLOW_COPY_AND_ASSIGN(ChromeBookmarkClientFactory);
-};
-
-#endif  // CHROME_BROWSER_BOOKMARKS_CHROME_BOOKMARK_CLIENT_FACTORY_H_
diff --git a/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc b/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc
index 04a1e10..2423538 100644
--- a/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc
+++ b/chrome/browser/sync/profile_sync_service_bookmark_unittest.cc
@@ -28,7 +28,6 @@
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
diff --git a/chrome/browser/ui/bookmarks/bookmark_editor_unittest.cc b/chrome/browser/ui/bookmarks/bookmark_editor_unittest.cc
index 1f51ee7..ad9381d 100644
--- a/chrome/browser/ui/bookmarks/bookmark_editor_unittest.cc
+++ b/chrome/browser/ui/bookmarks/bookmark_editor_unittest.cc
@@ -16,8 +16,7 @@ using bookmarks::BookmarkNode;
 namespace {
 
 TEST(BookmarkEditorTest, ApplyEditsWithNoFolderChange) {
-  bookmarks::TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(bookmarks::TestBookmarkClient::CreateModel());
   const BookmarkNode* bookmarkbar = model->bookmark_bar_node();
   model->AddURL(bookmarkbar, 0, ASCIIToUTF16("url0"), GURL("chrome://newtab"));
   model->AddURL(bookmarkbar, 1, ASCIIToUTF16("url1"), GURL("chrome://newtab"));
diff --git a/chrome/browser/ui/bookmarks/bookmark_ui_utils_desktop_unittest.cc b/chrome/browser/ui/bookmarks/bookmark_ui_utils_desktop_unittest.cc
index e297064..03797a8 100644
--- a/chrome/browser/ui/bookmarks/bookmark_ui_utils_desktop_unittest.cc
+++ b/chrome/browser/ui/bookmarks/bookmark_ui_utils_desktop_unittest.cc
@@ -22,8 +22,7 @@ class BookmarkUIUtilsTest : public testing::Test {
 };
 
 TEST_F(BookmarkUIUtilsTest, HasBookmarkURLs) {
-  bookmarks::TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(bookmarks::TestBookmarkClient::CreateModel());
 
   std::vector<const BookmarkNode*> nodes;
 
@@ -64,8 +63,7 @@ TEST_F(BookmarkUIUtilsTest, HasBookmarkURLs) {
 }
 
 TEST_F(BookmarkUIUtilsTest, HasBookmarkURLsAllowedInIncognitoMode) {
-  bookmarks::TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(bookmarks::TestBookmarkClient::CreateModel());
   TestingProfile profile;
 
   std::vector<const BookmarkNode*> nodes;
diff --git a/chrome/browser/ui/bookmarks/recently_used_folders_combo_model_unittest.cc b/chrome/browser/ui/bookmarks/recently_used_folders_combo_model_unittest.cc
index 45b66eb..952026f 100644
--- a/chrome/browser/ui/bookmarks/recently_used_folders_combo_model_unittest.cc
+++ b/chrome/browser/ui/bookmarks/recently_used_folders_combo_model_unittest.cc
@@ -64,8 +64,7 @@ RecentlyUsedFoldersComboModelTest::RecentlyUsedFoldersComboModelTest()
 
 // Verifies there are no duplicate nodes in the model.
 TEST_F(RecentlyUsedFoldersComboModelTest, NoDups) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> bookmark_model(client.CreateModel());
+  scoped_ptr<BookmarkModel> bookmark_model(TestBookmarkClient::CreateModel());
   const BookmarkNode* new_node = bookmark_model->AddURL(
       bookmark_model->bookmark_bar_node(), 0, base::ASCIIToUTF16("a"),
       GURL("http://a"));
@@ -79,8 +78,7 @@ TEST_F(RecentlyUsedFoldersComboModelTest, NoDups) {
 
 // Verifies that observers are notified on changes.
 TEST_F(RecentlyUsedFoldersComboModelTest, NotifyObserver) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> bookmark_model(client.CreateModel());
+  scoped_ptr<BookmarkModel> bookmark_model(TestBookmarkClient::CreateModel());
   const BookmarkNode* folder = bookmark_model->AddFolder(
       bookmark_model->bookmark_bar_node(), 0, base::ASCIIToUTF16("a"));
   const BookmarkNode* sub_folder = bookmark_model->AddFolder(
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 8629b6e..a9681c0 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -1455,8 +1455,6 @@
       'browser/bookmarks/bookmark_stats.h',
       'browser/bookmarks/chrome_bookmark_client.cc',
       'browser/bookmarks/chrome_bookmark_client.h',
-      'browser/bookmarks/chrome_bookmark_client_factory.cc',
-      'browser/bookmarks/chrome_bookmark_client_factory.h',
       'browser/bookmarks/managed_bookmark_service_factory.cc',
       'browser/bookmarks/managed_bookmark_service_factory.h',
       'browser/bookmarks/startup_task_runner_service_factory.cc',
diff --git a/chrome/test/base/testing_profile.cc b/chrome/test/base/testing_profile.cc
index 58a0819..1d034cc 100644
--- a/chrome/test/base/testing_profile.cc
+++ b/chrome/test/base/testing_profile.cc
@@ -21,7 +21,6 @@
 #include "chrome/browser/autocomplete/in_memory_url_index_factory.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
-#include "chrome/browser/bookmarks/chrome_bookmark_client_factory.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ -213,10 +212,9 @@ scoped_ptr<KeyedService> BuildInMemoryURLIndex(
 
 scoped_ptr<KeyedService> BuildBookmarkModel(content::BrowserContext* context) {
   Profile* profile = Profile::FromBrowserContext(context);
-  ChromeBookmarkClient* bookmark_client =
-      ChromeBookmarkClientFactory::GetForProfile(profile);
-  scoped_ptr<BookmarkModel> bookmark_model(new BookmarkModel(bookmark_client));
-  bookmark_client->Init(bookmark_model.get());
+  scoped_ptr<BookmarkModel> bookmark_model(
+      new BookmarkModel(make_scoped_ptr(new ChromeBookmarkClient(
+          profile, ManagedBookmarkServiceFactory::GetForProfile(profile)))));
   bookmark_model->Load(profile->GetPrefs(),
                        profile->GetPrefs()->GetString(prefs::kAcceptLanguages),
                        profile->GetPath(),
@@ -591,8 +589,6 @@ void TestingProfile::CreateBookmarkModel(bool delete_file) {
   }
   ManagedBookmarkServiceFactory::GetInstance()->SetTestingFactory(
       this, ManagedBookmarkServiceFactory::GetDefaultFactory());
-  ChromeBookmarkClientFactory::GetInstance()->SetTestingFactory(
-      this, ChromeBookmarkClientFactory::GetDefaultFactory());
   // This creates the BookmarkModel.
   ignore_result(BookmarkModelFactory::GetInstance()->SetTestingFactoryAndUse(
       this, BuildBookmarkModel));
diff --git a/components/bookmarks/browser/bookmark_client.cc b/components/bookmarks/browser/bookmark_client.cc
index fc22f3a..9325015 100644
--- a/components/bookmarks/browser/bookmark_client.cc
+++ b/components/bookmarks/browser/bookmark_client.cc
@@ -8,6 +8,8 @@
 
 namespace bookmarks {
 
+void BookmarkClient::Init(BookmarkModel* model) {}
+
 bool BookmarkClient::PreferTouchIcon() {
   return false;
 }
diff --git a/components/bookmarks/browser/bookmark_client.h b/components/bookmarks/browser/bookmark_client.h
index 3ea0269..5eb625f 100644
--- a/components/bookmarks/browser/bookmark_client.h
+++ b/components/bookmarks/browser/bookmark_client.h
@@ -24,12 +24,13 @@ struct UserMetricsAction;
 
 namespace bookmarks {
 
+class BookmarkModel;
 class BookmarkNode;
 class BookmarkPermanentNode;
 
 // This class abstracts operations that depends on the embedder's environment,
 // e.g. Chrome.
-class BookmarkClient : public KeyedService {
+class BookmarkClient {
  public:
   // Types representing a set of BookmarkNode and a mapping from BookmarkNode
   // to the number of time the corresponding URL has been typed by the user in
@@ -38,6 +39,11 @@ class BookmarkClient : public KeyedService {
   typedef std::pair<const BookmarkNode*, int> NodeTypedCountPair;
   typedef std::vector<NodeTypedCountPair> NodeTypedCountPairs;
 
+  virtual ~BookmarkClient() {}
+
+  // Called during initialization of BookmarkModel.
+  virtual void Init(BookmarkModel* model);
+
   // Returns true if the embedder favors touch icons over favicons.
   virtual bool PreferTouchIcon();
 
@@ -55,7 +61,7 @@ class BookmarkClient : public KeyedService {
       const favicon_base::FaviconImageCallback& callback,
       base::CancelableTaskTracker* tracker);
 
-    // Returns true if the embedder supports typed count for URL.
+  // Returns true if the embedder supports typed count for URL.
   virtual bool SupportsTypedCountForNodes();
 
   // Retrieves the number of time each BookmarkNode URL has been typed in
@@ -87,9 +93,6 @@ class BookmarkClient : public KeyedService {
   // should give the client a means to temporarily disable those checks.
   // http://crbug.com/49598
   virtual bool CanBeEditedByUser(const BookmarkNode* node) = 0;
-
- protected:
-  ~BookmarkClient() override {}
 };
 
 }  // namespace bookmarks
diff --git a/components/bookmarks/browser/bookmark_codec_unittest.cc b/components/bookmarks/browser/bookmark_codec_unittest.cc
index 26a2abf..51e4c18 100644
--- a/components/bookmarks/browser/bookmark_codec_unittest.cc
+++ b/components/bookmarks/browser/bookmark_codec_unittest.cc
@@ -88,20 +88,20 @@ class BookmarkCodecTest : public testing::Test {
  protected:
   // Helpers to create bookmark models with different data.
   BookmarkModel* CreateTestModel1() {
-    scoped_ptr<BookmarkModel> model(client_.CreateModel());
+    scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
     const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
     model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
     return model.release();
   }
   BookmarkModel* CreateTestModel2() {
-    scoped_ptr<BookmarkModel> model(client_.CreateModel());
+    scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
     const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
     model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
     model->AddURL(bookmark_bar, 1, ASCIIToUTF16(kUrl2Title), GURL(kUrl2Url));
     return model.release();
   }
   BookmarkModel* CreateTestModel3() {
-    scoped_ptr<BookmarkModel> model(client_.CreateModel());
+    scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
     const BookmarkNode* bookmark_bar = model->bookmark_bar_node();
     model->AddURL(bookmark_bar, 0, ASCIIToUTF16(kUrl1Title), GURL(kUrl1Url));
     const BookmarkNode* folder1 =
@@ -189,7 +189,7 @@ class BookmarkCodecTest : public testing::Test {
     EXPECT_EQ("", decoder.computed_checksum());
     EXPECT_EQ("", decoder.stored_checksum());
 
-    scoped_ptr<BookmarkModel> model(client_.CreateModel());
+    scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
     EXPECT_TRUE(Decode(&decoder, model.get(), value));
 
     *computed_checksum = decoder.computed_checksum();
@@ -227,8 +227,6 @@ class BookmarkCodecTest : public testing::Test {
     CheckIDs(model->other_node(), &assigned_ids);
     CheckIDs(model->mobile_node(), &assigned_ids);
   }
-
-  TestBookmarkClient client_;
 };
 
 TEST_F(BookmarkCodecTest, ChecksumEncodeDecodeTest) {
@@ -329,7 +327,7 @@ TEST_F(BookmarkCodecTest, PersistIDsTest) {
   BookmarkCodec encoder;
   scoped_ptr<base::Value> model_value(encoder.Encode(model_to_encode.get()));
 
-  scoped_ptr<BookmarkModel> decoded_model(client_.CreateModel());
+  scoped_ptr<BookmarkModel> decoded_model(TestBookmarkClient::CreateModel());
   BookmarkCodec decoder;
   ASSERT_TRUE(Decode(&decoder, decoded_model.get(), *model_value.get()));
   ASSERT_NO_FATAL_FAILURE(
@@ -350,7 +348,7 @@ TEST_F(BookmarkCodecTest, PersistIDsTest) {
   BookmarkCodec encoder2;
   scoped_ptr<base::Value> model_value2(encoder2.Encode(decoded_model.get()));
 
-  scoped_ptr<BookmarkModel> decoded_model2(client_.CreateModel());
+  scoped_ptr<BookmarkModel> decoded_model2(TestBookmarkClient::CreateModel());
   BookmarkCodec decoder2;
   ASSERT_TRUE(Decode(&decoder2, decoded_model2.get(), *model_value2.get()));
   ASSERT_NO_FATAL_FAILURE(
@@ -365,7 +363,7 @@ TEST_F(BookmarkCodecTest, CanDecodeModelWithoutMobileBookmarks) {
   JSONFileValueDeserializer deserializer(test_file);
   scoped_ptr<base::Value> root = deserializer.Deserialize(NULL, NULL);
 
-  scoped_ptr<BookmarkModel> decoded_model(client_.CreateModel());
+  scoped_ptr<BookmarkModel> decoded_model(TestBookmarkClient::CreateModel());
   BookmarkCodec decoder;
   ASSERT_TRUE(Decode(&decoder, decoded_model.get(), *root.get()));
   ExpectIDsUnique(decoded_model.get());
@@ -451,7 +449,7 @@ TEST_F(BookmarkCodecTest, CanDecodeMetaInfoAsString) {
   JSONFileValueDeserializer deserializer(test_file);
   scoped_ptr<base::Value> root = deserializer.Deserialize(NULL, NULL);
 
-  scoped_ptr<BookmarkModel> model(client_.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   BookmarkCodec decoder;
   ASSERT_TRUE(Decode(&decoder, model.get(), *root.get()));
 
diff --git a/components/bookmarks/browser/bookmark_expanded_state_tracker_unittest.cc b/components/bookmarks/browser/bookmark_expanded_state_tracker_unittest.cc
index 56aa491..2b97a42 100644
--- a/components/bookmarks/browser/bookmark_expanded_state_tracker_unittest.cc
+++ b/components/bookmarks/browser/bookmark_expanded_state_tracker_unittest.cc
@@ -31,7 +31,6 @@ class BookmarkExpandedStateTrackerTest : public testing::Test {
 
   base::MessageLoop message_loop_;
   TestingPrefServiceSimple prefs_;
-  TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
 
   DISALLOW_COPY_AND_ASSIGN(BookmarkExpandedStateTrackerTest);
@@ -45,7 +44,7 @@ void BookmarkExpandedStateTrackerTest::SetUp() {
   prefs_.registry()->RegisterListPref(prefs::kBookmarkEditorExpandedNodes,
                                       new base::ListValue);
   prefs_.registry()->RegisterListPref(prefs::kManagedBookmarks);
-  model_.reset(new BookmarkModel(&client_));
+  model_.reset(new BookmarkModel(make_scoped_ptr(new TestBookmarkClient())));
   model_->Load(&prefs_, std::string(), base::FilePath(),
                base::ThreadTaskRunnerHandle::Get(),
                base::ThreadTaskRunnerHandle::Get());
diff --git a/components/bookmarks/browser/bookmark_index_unittest.cc b/components/bookmarks/browser/bookmark_index_unittest.cc
index 514172d..8a365a4 100644
--- a/components/bookmarks/browser/bookmark_index_unittest.cc
+++ b/components/bookmarks/browser/bookmark_index_unittest.cc
@@ -57,7 +57,7 @@ class BookmarkClientMock : public TestBookmarkClient {
 
 class BookmarkIndexTest : public testing::Test {
  public:
-  BookmarkIndexTest() : model_(client_.CreateModel()) {}
+  BookmarkIndexTest() : model_(TestBookmarkClient::CreateModel()) {}
 
   typedef std::pair<std::string, std::string> TitleAndURL;
 
@@ -137,7 +137,6 @@ class BookmarkIndexTest : public testing::Test {
   }
 
  protected:
-  TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
 
  private:
@@ -212,7 +211,7 @@ TEST_F(BookmarkIndexTest, GetBookmarksMatching) {
     ExpectMatches(data[i].query, query_parser::MatchingAlgorithm::DEFAULT,
                   expected);
 
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
@@ -274,7 +273,7 @@ TEST_F(BookmarkIndexTest, GetBookmarksMatchingAlwaysPrefixSearch) {
                   query_parser::MatchingAlgorithm::ALWAYS_PREFIX_SEARCH,
                   expected);
 
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
@@ -323,7 +322,7 @@ TEST_F(BookmarkIndexTest, GetBookmarksMatchingWithURLs) {
   };
 
   for (size_t i = 0; i < arraysize(data); ++i) {
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
     std::vector<TitleAndURL> bookmarks;
     bookmarks.push_back(TitleAndURL(data[i].title, data[i].url));
     AddBookmarks(bookmarks);
@@ -361,7 +360,7 @@ TEST_F(BookmarkIndexTest, Normalization) {
     std::vector<BookmarkMatch> matches;
     model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 10, &matches);
     EXPECT_EQ(1u, matches.size());
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
@@ -398,7 +397,7 @@ TEST_F(BookmarkIndexTest, MatchPositionsTitles) {
     ExpectMatchPositions(matches[0].title_match_positions,
                          expected_title_matches);
 
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
   }
 }
 
@@ -434,7 +433,7 @@ TEST_F(BookmarkIndexTest, MatchPositionsURLs) {
   };
 
   for (size_t i = 0; i < arraysize(data); ++i) {
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
     std::vector<TitleAndURL> bookmarks;
     TitleAndURL bookmark("123456", data[i].url);
     bookmarks.push_back(bookmark);
@@ -527,8 +526,8 @@ TEST_F(BookmarkIndexTest, GetResultsSortedByTypedCount) {
   for (size_t i = 0; i < arraysize(data); ++i)
     typed_count_map.insert(std::make_pair(data[i].url, data[i].typed_count));
 
-  BookmarkClientMock client(typed_count_map);
-  scoped_ptr<BookmarkModel> model = client.CreateModel();
+  scoped_ptr<BookmarkModel> model = TestBookmarkClient::CreateModelWithClient(
+      make_scoped_ptr(new BookmarkClientMock(typed_count_map)));
 
   for (size_t i = 0; i < arraysize(data); ++i)
     // Populate the BookmarkIndex.
diff --git a/components/bookmarks/browser/bookmark_model.cc b/components/bookmarks/browser/bookmark_model.cc
index 3f9f459..3b50276 100644
--- a/components/bookmarks/browser/bookmark_model.cc
+++ b/components/bookmarks/browser/bookmark_model.cc
@@ -112,8 +112,8 @@ class EmptyUndoDelegate : public BookmarkUndoDelegate {
 
 // BookmarkModel --------------------------------------------------------------
 
-BookmarkModel::BookmarkModel(BookmarkClient* client)
-    : client_(client),
+BookmarkModel::BookmarkModel(scoped_ptr<BookmarkClient> client)
+    : client_(std::move(client)),
       loaded_(false),
       root_(GURL()),
       bookmark_bar_node_(NULL),
@@ -127,6 +127,7 @@ BookmarkModel::BookmarkModel(BookmarkClient* client)
       undo_delegate_(nullptr),
       empty_undo_delegate_(new EmptyUndoDelegate) {
   DCHECK(client_);
+  client_->Init(this);
 }
 
 BookmarkModel::~BookmarkModel() {
@@ -862,7 +863,7 @@ void BookmarkModel::DoneLoading(scoped_ptr<BookmarkLoadDetails> details) {
 
   std::stable_sort(root_children.begin(),
                    root_children.end(),
-                   VisibilityComparator(client_));
+                   VisibilityComparator(client_.get()));
   for (size_t i = 0; i < root_children.size(); ++i)
     root_.Add(root_children[i], static_cast<int>(i));
 
@@ -1107,7 +1108,7 @@ scoped_ptr<BookmarkLoadDetails> BookmarkModel::CreateLoadDetails(
       other_node,
       mobile_node,
       client_->GetLoadExtraNodesCallback(),
-      new BookmarkIndex(client_, accept_languages),
+      new BookmarkIndex(client_.get(), accept_languages),
       next_node_id_));
 }
 
diff --git a/components/bookmarks/browser/bookmark_model.h b/components/bookmarks/browser/bookmark_model.h
index 2bae0d2..a5138f2 100644
--- a/components/bookmarks/browser/bookmark_model.h
+++ b/components/bookmarks/browser/bookmark_model.h
@@ -72,7 +72,7 @@ class BookmarkModel : public BookmarkUndoProvider,
     base::string16 title;
   };
 
-  explicit BookmarkModel(BookmarkClient* client);
+  explicit BookmarkModel(scoped_ptr<BookmarkClient> client);
   ~BookmarkModel() override;
 
   // KeyedService:
@@ -310,7 +310,7 @@ class BookmarkModel : public BookmarkUndoProvider,
                          const GURL& icon_url);
 
   // Returns the client used by this BookmarkModel.
-  BookmarkClient* client() const { return client_; }
+  BookmarkClient* client() const { return client_.get(); }
 
   void SetUndoDelegate(BookmarkUndoDelegate* undo_delegate);
 
@@ -421,7 +421,7 @@ class BookmarkModel : public BookmarkUndoProvider,
 
   BookmarkUndoDelegate* undo_delegate() const;
 
-  BookmarkClient* const client_;
+  scoped_ptr<BookmarkClient> client_;
 
   // Whether the initial set of data has been loaded.
   bool loaded_;
diff --git a/components/bookmarks/browser/bookmark_model_unittest.cc b/components/bookmarks/browser/bookmark_model_unittest.cc
index d9e724a..9067665 100644
--- a/components/bookmarks/browser/bookmark_model_unittest.cc
+++ b/components/bookmarks/browser/bookmark_model_unittest.cc
@@ -270,7 +270,7 @@ class BookmarkModelTest : public testing::Test,
     int64_t node_id;
   };
 
-  BookmarkModelTest() : model_(client_.CreateModel()) {
+  BookmarkModelTest() : model_(TestBookmarkClient::CreateModel()) {
     model_->AddObserver(this);
     ClearCounts();
   }
@@ -423,13 +423,16 @@ class BookmarkModelTest : public testing::Test,
   int AllNodesRemovedObserverCount() const { return all_bookmarks_removed_; }
 
   BookmarkPermanentNode* ReloadModelWithExtraNode() {
+    model_->RemoveObserver(this);
+
     BookmarkPermanentNode* extra_node = new BookmarkPermanentNode(100);
     BookmarkPermanentNodeList extra_nodes;
     extra_nodes.push_back(extra_node);
-    client_.SetExtraNodesToLoad(std::move(extra_nodes));
 
-    model_->RemoveObserver(this);
-    model_ = client_.CreateModel();
+    scoped_ptr<TestBookmarkClient> client(new TestBookmarkClient);
+    client->SetExtraNodesToLoad(std::move(extra_nodes));
+
+    model_ = TestBookmarkClient::CreateModelWithClient(std::move(client));
     model_->AddObserver(this);
     ClearCounts();
 
@@ -440,7 +443,6 @@ class BookmarkModelTest : public testing::Test,
   }
 
  protected:
-  TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
   ObserverDetails observer_details_;
   std::vector<NodeRemovalDetail> node_removal_details_;
@@ -1231,10 +1233,9 @@ TEST(BookmarkModelTest2, CreateAndRestore) {
     { "a [ b ]", "" },
     { "a b c [ d e [ f ] ]", "g h i [ j k [ l ] ]"},
   };
-  TestBookmarkClient client;
   scoped_ptr<BookmarkModel> model;
   for (size_t i = 0; i < arraysize(data); ++i) {
-    model = client.CreateModel();
+    model = TestBookmarkClient::CreateModel();
 
     TestNode bbn;
     PopulateNodeFromString(data[i].bbn_contents, &bbn);
@@ -1260,7 +1261,7 @@ TEST(BookmarkModelTest2, CreateAndRestore) {
 class BookmarkModelFaviconTest : public testing::Test,
                                  public BookmarkModelObserver {
  public:
-  BookmarkModelFaviconTest() : model_(client_.CreateModel()) {
+  BookmarkModelFaviconTest() : model_(TestBookmarkClient::CreateModel()) {
     model_->AddObserver(this);
   }
 
@@ -1325,7 +1326,6 @@ class BookmarkModelFaviconTest : public testing::Test,
       const std::set<GURL>& removed_urls) override {
   }
 
-  TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
   std::vector<const BookmarkNode*> updated_nodes_;
 
diff --git a/components/bookmarks/browser/bookmark_node_data_unittest.cc b/components/bookmarks/browser/bookmark_node_data_unittest.cc
index b5f332c..fc457ce 100644
--- a/components/bookmarks/browser/bookmark_node_data_unittest.cc
+++ b/components/bookmarks/browser/bookmark_node_data_unittest.cc
@@ -29,7 +29,7 @@ class BookmarkNodeDataTest : public testing::Test {
 
   void SetUp() override {
     event_source_ = ui::PlatformEventSource::CreateDefault();
-    model_ = client_.CreateModel();
+    model_ = TestBookmarkClient::CreateModel();
     test::WaitForBookmarkModelToLoad(model_.get());
     bool success = profile_dir_.CreateUniqueTempDir();
     ASSERT_TRUE(success);
@@ -52,7 +52,6 @@ class BookmarkNodeDataTest : public testing::Test {
 
  private:
   base::ScopedTempDir profile_dir_;
-  TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
   scoped_ptr<ui::PlatformEventSource> event_source_;
   base::MessageLoopForUI loop_;
diff --git a/components/bookmarks/browser/bookmark_utils_unittest.cc b/components/bookmarks/browser/bookmark_utils_unittest.cc
index 29225d4..d9b0186 100644
--- a/components/bookmarks/browser/bookmark_utils_unittest.cc
+++ b/components/bookmarks/browser/bookmark_utils_unittest.cc
@@ -78,8 +78,7 @@ class BookmarkUtilsTest : public testing::Test,
 };
 
 TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesWordPhraseQuery) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const BookmarkNode* node1 = model->AddURL(model->other_node(),
                                             0,
                                             ASCIIToUTF16("foo bar"),
@@ -136,8 +135,7 @@ TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesWordPhraseQuery) {
 
 // Check exact matching against a URL query.
 TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesUrl) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const BookmarkNode* node1 = model->AddURL(model->other_node(),
                                             0,
                                             ASCIIToUTF16("Google"),
@@ -172,8 +170,7 @@ TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesUrl) {
 
 // Check exact matching against a title query.
 TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesTitle) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const BookmarkNode* node1 = model->AddURL(model->other_node(),
                                             0,
                                             ASCIIToUTF16("Google"),
@@ -210,8 +207,7 @@ TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesTitle) {
 
 // Check matching against a query with multiple predicates.
 TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesConjunction) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const BookmarkNode* node1 = model->AddURL(model->other_node(),
                                             0,
                                             ASCIIToUTF16("Google"),
@@ -262,8 +258,7 @@ TEST_F(BookmarkUtilsTest, GetBookmarksMatchingPropertiesConjunction) {
 // Copy and paste is not yet supported on iOS. http://crbug.com/228147
 #if !defined(OS_IOS)
 TEST_F(BookmarkUtilsTest, PasteBookmarkFromURL) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const base::string16 url_text = ASCIIToUTF16("http://www.google.com/");
   const BookmarkNode* new_folder = model->AddFolder(
       model->bookmark_bar_node(), 0, ASCIIToUTF16("New_Folder"));
@@ -292,8 +287,7 @@ TEST_F(BookmarkUtilsTest, PasteBookmarkFromURL) {
 }
 
 TEST_F(BookmarkUtilsTest, CopyPaste) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const BookmarkNode* node = model->AddURL(model->other_node(),
                                            0,
                                            ASCIIToUTF16("foo bar"),
@@ -321,8 +315,7 @@ TEST_F(BookmarkUtilsTest, CopyPaste) {
 // Test for updating title such that url and title pair are unique among the
 // children of parent.
 TEST_F(BookmarkUtilsTest, MakeTitleUnique) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const base::string16 url_text = ASCIIToUTF16("http://www.google.com/");
   const base::string16 title_text = ASCIIToUTF16("foobar");
   const BookmarkNode* bookmark_bar_node = model->bookmark_bar_node();
@@ -355,8 +348,7 @@ TEST_F(BookmarkUtilsTest, MakeTitleUnique) {
 }
 
 TEST_F(BookmarkUtilsTest, CopyPasteMetaInfo) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   const BookmarkNode* node = model->AddURL(model->other_node(),
                                            0,
                                            ASCIIToUTF16("foo bar"),
@@ -398,8 +390,7 @@ TEST_F(BookmarkUtilsTest, CopyPasteMetaInfo) {
 #define MAYBE_CutToClipboard CutToClipboard
 #endif
 TEST_F(BookmarkUtilsTest, MAYBE_CutToClipboard) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   model->AddObserver(this);
 
   base::string16 title(ASCIIToUTF16("foo"));
@@ -424,14 +415,15 @@ TEST_F(BookmarkUtilsTest, MAYBE_CutToClipboard) {
 }
 
 TEST_F(BookmarkUtilsTest, PasteNonEditableNodes) {
-  TestBookmarkClient client;
   // Load a model with an extra node that is not editable.
+  scoped_ptr<TestBookmarkClient> client(new TestBookmarkClient());
   BookmarkPermanentNode* extra_node = new BookmarkPermanentNode(100);
   BookmarkPermanentNodeList extra_nodes;
   extra_nodes.push_back(extra_node);
-  client.SetExtraNodesToLoad(std::move(extra_nodes));
+  client->SetExtraNodesToLoad(std::move(extra_nodes));
 
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(
+      TestBookmarkClient::CreateModelWithClient(std::move(client)));
   const BookmarkNode* node = model->AddURL(model->other_node(),
                                            0,
                                            ASCIIToUTF16("foo bar"),
@@ -446,15 +438,14 @@ TEST_F(BookmarkUtilsTest, PasteNonEditableNodes) {
   EXPECT_TRUE(CanPasteFromClipboard(model.get(), model->bookmark_bar_node()));
 
   // But it can't be pasted into a non-editable folder.
-  BookmarkClient* upcast = &client;
+  BookmarkClient* upcast = model->client();
   EXPECT_FALSE(upcast->CanBeEditedByUser(extra_node));
   EXPECT_FALSE(CanPasteFromClipboard(model.get(), extra_node));
 }
 #endif  // !defined(OS_IOS)
 
 TEST_F(BookmarkUtilsTest, GetParentForNewNodes) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   // This tests the case where selection contains one item and that item is a
   // folder.
   std::vector<const BookmarkNode*> nodes;
@@ -495,8 +486,7 @@ TEST_F(BookmarkUtilsTest, GetParentForNewNodes) {
 
 // Verifies that meta info is copied when nodes are cloned.
 TEST_F(BookmarkUtilsTest, CloneMetaInfo) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   // Add a node containing meta info.
   const BookmarkNode* node = model->AddURL(model->other_node(),
                                            0,
@@ -529,8 +519,7 @@ TEST_F(BookmarkUtilsTest, CloneMetaInfo) {
 // Verifies that meta info fields in the non cloned set are not copied when
 // cloning a bookmark.
 TEST_F(BookmarkUtilsTest, CloneBookmarkResetsNonClonedKey) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   model->AddNonClonedKey("foo");
   const BookmarkNode* parent = model->other_node();
   const BookmarkNode* node = model->AddURL(
@@ -555,8 +544,7 @@ TEST_F(BookmarkUtilsTest, CloneBookmarkResetsNonClonedKey) {
 // Verifies that meta info fields in the non cloned set are not copied when
 // cloning a folder.
 TEST_F(BookmarkUtilsTest, CloneFolderResetsNonClonedKey) {
-  TestBookmarkClient client;
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(TestBookmarkClient::CreateModel());
   model->AddNonClonedKey("foo");
   const BookmarkNode* parent = model->other_node();
   const BookmarkNode* node = model->AddFolder(parent, 0, ASCIIToUTF16("title"));
@@ -578,14 +566,15 @@ TEST_F(BookmarkUtilsTest, CloneFolderResetsNonClonedKey) {
 }
 
 TEST_F(BookmarkUtilsTest, RemoveAllBookmarks) {
-  TestBookmarkClient client;
   // Load a model with an extra node that is not editable.
+  scoped_ptr<TestBookmarkClient> client(new TestBookmarkClient());
   BookmarkPermanentNode* extra_node = new BookmarkPermanentNode(100);
   BookmarkPermanentNodeList extra_nodes;
   extra_nodes.push_back(extra_node);
-  client.SetExtraNodesToLoad(std::move(extra_nodes));
+  client->SetExtraNodesToLoad(std::move(extra_nodes));
 
-  scoped_ptr<BookmarkModel> model(client.CreateModel());
+  scoped_ptr<BookmarkModel> model(
+      TestBookmarkClient::CreateModelWithClient(std::move(client)));
   EXPECT_TRUE(model->bookmark_bar_node()->empty());
   EXPECT_TRUE(model->other_node()->empty());
   EXPECT_TRUE(model->mobile_node()->empty());
diff --git a/components/bookmarks/managed/managed_bookmarks_tracker_unittest.cc b/components/bookmarks/managed/managed_bookmarks_tracker_unittest.cc
index 3ce78c3..83f3bcd 100644
--- a/components/bookmarks/managed/managed_bookmarks_tracker_unittest.cc
+++ b/components/bookmarks/managed/managed_bookmarks_tracker_unittest.cc
@@ -63,9 +63,11 @@ class ManagedBookmarksTrackerTest : public testing::Test {
 
     BookmarkPermanentNodeList extra_nodes;
     extra_nodes.push_back(managed_node);
-    client_.SetExtraNodesToLoad(std::move(extra_nodes));
 
-    model_.reset(new BookmarkModel(&client_));
+    scoped_ptr<TestBookmarkClient> client(new TestBookmarkClient);
+    client->SetExtraNodesToLoad(std::move(extra_nodes));
+    model_.reset(new BookmarkModel(std::move(client)));
+
     model_->AddObserver(&observer_);
     EXPECT_CALL(observer_, BookmarkModelLoaded(model_.get(), _));
     model_->Load(&prefs_, std::string(), base::FilePath(),
@@ -74,8 +76,10 @@ class ManagedBookmarksTrackerTest : public testing::Test {
     test::WaitForBookmarkModelToLoad(model_.get());
     Mock::VerifyAndClearExpectations(&observer_);
 
-    ASSERT_EQ(1u, client_.extra_nodes().size());
-    managed_node_ = client_.extra_nodes()[0];
+    TestBookmarkClient* client_ptr =
+        static_cast<TestBookmarkClient*>(model_->client());
+    ASSERT_EQ(1u, client_ptr->extra_nodes().size());
+    managed_node_ = client_ptr->extra_nodes()[0];
     ASSERT_EQ(managed_node, managed_node_);
 
     managed_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
@@ -168,7 +172,6 @@ class ManagedBookmarksTrackerTest : public testing::Test {
 
   base::MessageLoop loop_;
   TestingPrefServiceSimple prefs_;
-  TestBookmarkClient client_;
   scoped_ptr<BookmarkModel> model_;
   MockBookmarkModelObserver observer_;
   BookmarkPermanentNode* managed_node_;
diff --git a/components/bookmarks/test/test_bookmark_client.cc b/components/bookmarks/test/test_bookmark_client.cc
index 89ca479..a4fddc2 100644
--- a/components/bookmarks/test/test_bookmark_client.cc
+++ b/components/bookmarks/test/test_bookmark_client.cc
@@ -20,8 +20,16 @@ TestBookmarkClient::TestBookmarkClient() {}
 
 TestBookmarkClient::~TestBookmarkClient() {}
 
+// static
 scoped_ptr<BookmarkModel> TestBookmarkClient::CreateModel() {
-  scoped_ptr<BookmarkModel> bookmark_model(new BookmarkModel(this));
+  return CreateModelWithClient(make_scoped_ptr(new TestBookmarkClient));
+}
+
+// static
+scoped_ptr<BookmarkModel> TestBookmarkClient::CreateModelWithClient(
+    scoped_ptr<BookmarkClient> client) {
+  scoped_ptr<BookmarkModel> bookmark_model(
+      new BookmarkModel(std::move(client)));
   scoped_ptr<BookmarkLoadDetails> details =
       bookmark_model->CreateLoadDetails(std::string());
   details->LoadExtraNodes();
diff --git a/components/bookmarks/test/test_bookmark_client.h b/components/bookmarks/test/test_bookmark_client.h
index ef7b8db..a97019bc 100644
--- a/components/bookmarks/test/test_bookmark_client.h
+++ b/components/bookmarks/test/test_bookmark_client.h
@@ -20,9 +20,12 @@ class TestBookmarkClient : public BookmarkClient {
   TestBookmarkClient();
   ~TestBookmarkClient() override;
 
-  // Create a BookmarkModel using this object as its client. The returned
-  // BookmarkModel* is owned by the caller.
-  scoped_ptr<BookmarkModel> CreateModel();
+  // Returns a new BookmarkModel using a TestBookmarkClient.
+  static scoped_ptr<BookmarkModel> CreateModel();
+
+  // Returns a new BookmarkModel using |client|.
+  static scoped_ptr<BookmarkModel> CreateModelWithClient(
+      scoped_ptr<BookmarkClient> client);
 
   // Sets the list of extra nodes to be returned by the next call to
   // CreateModel() or GetLoadExtraNodesCallback().
diff --git a/components/offline_pages/offline_page_model_unittest.cc b/components/offline_pages/offline_page_model_unittest.cc
index 0f5aeb7..253dc67 100644
--- a/components/offline_pages/offline_page_model_unittest.cc
+++ b/components/offline_pages/offline_page_model_unittest.cc
@@ -764,7 +764,6 @@ class OfflinePageModelBookmarkChangeTest :
   }
 
  private:
-  bookmarks::TestBookmarkClient bookmark_client_;
   scoped_ptr<bookmarks::BookmarkModel> bookmark_model_;
   bookmarks::BookmarkUndoProvider* bookmark_undo_provider_;
   const bookmarks::BookmarkNode* removed_bookmark_parent_;
@@ -774,11 +773,10 @@ class OfflinePageModelBookmarkChangeTest :
 
 OfflinePageModelBookmarkChangeTest::OfflinePageModelBookmarkChangeTest()
     : OfflinePageModelTest(),
-      bookmark_model_(bookmark_client_.CreateModel()),
+      bookmark_model_(bookmarks::TestBookmarkClient::CreateModel()),
       bookmark_undo_provider_(nullptr),
       removed_bookmark_parent_(nullptr),
-      removed_bookmark_index_(-1) {
-}
+      removed_bookmark_index_(-1) {}
 
 OfflinePageModelBookmarkChangeTest::~OfflinePageModelBookmarkChangeTest() {
 }
diff --git a/components/omnibox/browser/bookmark_provider_unittest.cc b/components/omnibox/browser/bookmark_provider_unittest.cc
index fbc7ad8d..fe33368 100644
--- a/components/omnibox/browser/bookmark_provider_unittest.cc
+++ b/components/omnibox/browser/bookmark_provider_unittest.cc
@@ -172,7 +172,6 @@ class BookmarkProviderTest : public testing::Test {
   void SetUp() override;
 
   base::MessageLoop message_loop_;
-  bookmarks::TestBookmarkClient bookmark_client_;
   scoped_ptr<MockAutocompleteProviderClient> provider_client_;
   scoped_ptr<BookmarkModel> model_;
   scoped_refptr<BookmarkProvider> provider_;
@@ -183,7 +182,7 @@ class BookmarkProviderTest : public testing::Test {
 };
 
 BookmarkProviderTest::BookmarkProviderTest() {
-  model_ = bookmark_client_.CreateModel();
+  model_ = bookmarks::TestBookmarkClient::CreateModel();
 }
 
 void BookmarkProviderTest::SetUp() {
diff --git a/components/omnibox/browser/history_quick_provider_unittest.cc b/components/omnibox/browser/history_quick_provider_unittest.cc
index 410004a..cec085b 100644
--- a/components/omnibox/browser/history_quick_provider_unittest.cc
+++ b/components/omnibox/browser/history_quick_provider_unittest.cc
@@ -201,7 +201,7 @@ class QuitTask : public history::HistoryDBTask {
 class FakeAutocompleteProviderClient : public MockAutocompleteProviderClient {
  public:
   FakeAutocompleteProviderClient() {
-    bookmark_model_ = bookmark_client_.CreateModel();
+    bookmark_model_ = bookmarks::TestBookmarkClient::CreateModel();
     set_template_url_service(
         make_scoped_ptr(new TemplateURLService(nullptr, 0)));
   }
@@ -233,7 +233,6 @@ class FakeAutocompleteProviderClient : public MockAutocompleteProviderClient {
   }
 
  private:
-  bookmarks::TestBookmarkClient bookmark_client_;
   scoped_ptr<bookmarks::BookmarkModel> bookmark_model_;
   TestSchemeClassifier scheme_classifier_;
   SearchTermsData search_terms_data_;
diff --git a/components/sync_bookmarks/bookmark_data_type_controller_unittest.cc b/components/sync_bookmarks/bookmark_data_type_controller_unittest.cc
index 0082fe8..ba84fe4 100644
--- a/components/sync_bookmarks/bookmark_data_type_controller_unittest.cc
+++ b/components/sync_bookmarks/bookmark_data_type_controller_unittest.cc
@@ -71,7 +71,6 @@ class SyncBookmarkDataTypeControllerTest : public testing::Test,
   void SetUp() override {
     model_associator_ = new ModelAssociatorMock();
     change_processor_ = new ChangeProcessorMock();
-    bookmark_client_.reset(new bookmarks::TestBookmarkClient());
     history_service_.reset(new HistoryMock());
     profile_sync_factory_.reset(
         new SyncApiComponentFactoryMock(model_associator_,
@@ -88,7 +87,8 @@ class SyncBookmarkDataTypeControllerTest : public testing::Test,
   };
 
   void CreateBookmarkModel(BookmarkLoadPolicy bookmark_load_policy) {
-    bookmark_model_.reset(new BookmarkModel(bookmark_client_.get()));
+    bookmark_model_.reset(new BookmarkModel(
+        make_scoped_ptr(new bookmarks::TestBookmarkClient())));
     if (bookmark_load_policy == LOAD_MODEL) {
       TestingPrefServiceSimple prefs;
       bookmark_model_->Load(&prefs, std::string(), base::FilePath(),
@@ -136,7 +136,6 @@ class SyncBookmarkDataTypeControllerTest : public testing::Test,
   base::MessageLoop message_loop_;
   scoped_refptr<BookmarkDataTypeController> bookmark_dtc_;
   scoped_ptr<SyncApiComponentFactoryMock> profile_sync_factory_;
-  scoped_ptr<bookmarks::TestBookmarkClient> bookmark_client_;
   scoped_ptr<BookmarkModel> bookmark_model_;
   scoped_ptr<HistoryMock> history_service_;
   sync_driver::FakeSyncService service_;
diff --git a/components/undo/bookmark_undo_service_test.cc b/components/undo/bookmark_undo_service_test.cc
index ea3752e..3716845 100644
--- a/components/undo/bookmark_undo_service_test.cc
+++ b/components/undo/bookmark_undo_service_test.cc
@@ -30,7 +30,6 @@ class BookmarkUndoServiceTest : public testing::Test {
   BookmarkUndoService* GetUndoService();
 
  private:
-  scoped_ptr<bookmarks::TestBookmarkClient> test_bookmark_client_;
   scoped_ptr<bookmarks::BookmarkModel> bookmark_model_;
   scoped_ptr<BookmarkUndoService> bookmark_undo_service_;
 
@@ -40,11 +39,9 @@ class BookmarkUndoServiceTest : public testing::Test {
 BookmarkUndoServiceTest::BookmarkUndoServiceTest() {}
 
 void BookmarkUndoServiceTest::SetUp() {
-  DCHECK(!test_bookmark_client_);
   DCHECK(!bookmark_model_);
   DCHECK(!bookmark_undo_service_);
-  test_bookmark_client_.reset(new bookmarks::TestBookmarkClient);
-  bookmark_model_ = test_bookmark_client_->CreateModel();
+  bookmark_model_ = bookmarks::TestBookmarkClient::CreateModel();
   bookmark_undo_service_.reset(new BookmarkUndoService);
   bookmark_undo_service_->Start(bookmark_model_.get());
   bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model_.get());
@@ -62,10 +59,8 @@ void BookmarkUndoServiceTest::TearDown() {
   // Implement two-phase KeyedService shutdown for test KeyedServices.
   bookmark_undo_service_->Shutdown();
   bookmark_model_->Shutdown();
-  test_bookmark_client_->Shutdown();
   bookmark_undo_service_.reset();
   bookmark_model_.reset();
-  test_bookmark_client_.reset();
 }
 
 TEST_F(BookmarkUndoServiceTest, AddBookmark) {
diff --git a/ios/chrome/browser/BUILD.gn b/ios/chrome/browser/BUILD.gn
index cea1de6..c95a033 100644
--- a/ios/chrome/browser/BUILD.gn
+++ b/ios/chrome/browser/BUILD.gn
@@ -53,8 +53,6 @@ source_set("browser") {
     "autofill/form_suggestion_view_client.h",
     "autofill/personal_data_manager_factory.cc",
     "autofill/personal_data_manager_factory.h",
-    "bookmarks/bookmark_client_factory.cc",
-    "bookmarks/bookmark_client_factory.h",
     "bookmarks/bookmark_client_impl.cc",
     "bookmarks/bookmark_client_impl.h",
     "bookmarks/bookmark_model_factory.cc",
diff --git a/ios/chrome/browser/bookmarks/bookmark_client_factory.cc b/ios/chrome/browser/bookmarks/bookmark_client_factory.cc
deleted file mode 100644
index 08f5c54..0000000
--- a/ios/chrome/browser/bookmarks/bookmark_client_factory.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2015 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 "ios/chrome/browser/bookmarks/bookmark_client_factory.h"
-
-#include "base/memory/singleton.h"
-#include "components/keyed_service/core/service_access_type.h"
-#include "components/keyed_service/ios/browser_state_dependency_manager.h"
-#include "ios/chrome/browser/bookmarks/bookmark_client_impl.h"
-#include "ios/chrome/browser/browser_state/browser_state_otr_helper.h"
-#include "ios/public/provider/chrome/browser/browser_state/chrome_browser_state.h"
-
-namespace {
-
-scoped_ptr<KeyedService> BuildBookmarkClientImpl(web::BrowserState* context) {
-  ios::ChromeBrowserState* browser_state =
-      ios::ChromeBrowserState::FromBrowserState(context);
-  return make_scoped_ptr(new BookmarkClientImpl(browser_state));
-}
-
-}  // namespace
-
-// static
-BookmarkClientImpl* BookmarkClientFactory::GetForBrowserState(
-    ios::ChromeBrowserState* browser_state) {
-  return static_cast<BookmarkClientImpl*>(
-      GetInstance()->GetServiceForBrowserState(browser_state, true));
-}
-
-// static
-BookmarkClientFactory* BookmarkClientFactory::GetInstance() {
-  return base::Singleton<BookmarkClientFactory>::get();
-}
-
-// static
-BrowserStateKeyedServiceFactory::TestingFactoryFunction
-BookmarkClientFactory::GetDefaultFactory() {
-  return &BuildBookmarkClientImpl;
-}
-
-BookmarkClientFactory::BookmarkClientFactory()
-    : BrowserStateKeyedServiceFactory(
-          "BookmarkClient",
-          BrowserStateDependencyManager::GetInstance()) {
-}
-
-BookmarkClientFactory::~BookmarkClientFactory() {}
-
-scoped_ptr<KeyedService> BookmarkClientFactory::BuildServiceInstanceFor(
-    web::BrowserState* context) const {
-  return BuildBookmarkClientImpl(context);
-}
-
-web::BrowserState* BookmarkClientFactory::GetBrowserStateToUse(
-    web::BrowserState* context) const {
-  return GetBrowserStateRedirectedInIncognito(context);
-}
-
-bool BookmarkClientFactory::ServiceIsNULLWhileTesting() const {
-  return true;
-}
diff --git a/ios/chrome/browser/bookmarks/bookmark_client_factory.h b/ios/chrome/browser/bookmarks/bookmark_client_factory.h
deleted file mode 100644
index 2217abc..0000000
--- a/ios/chrome/browser/bookmarks/bookmark_client_factory.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2015 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.
-
-#ifndef IOS_CHROME_BROWSER_BOOKMARKS_BOOKMARK_CLIENT_FACTORY_H_
-#define IOS_CHROME_BROWSER_BOOKMARKS_BOOKMARK_CLIENT_FACTORY_H_
-
-#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
-#include "components/keyed_service/ios/browser_state_keyed_service_factory.h"
-
-namespace base {
-template <typename T>
-struct DefaultSingletonTraits;
-}  // namespase base
-
-class BookmarkClientImpl;
-
-namespace ios {
-class ChromeBrowserState;
-}
-
-// Singleton that owns all BookmarkClientImpls and associates them with
-// ios::ChromeBrowserState.
-class BookmarkClientFactory : public BrowserStateKeyedServiceFactory {
- public:
-  static BookmarkClientImpl* GetForBrowserState(
-      ios::ChromeBrowserState* browser_state);
-  static BookmarkClientFactory* GetInstance();
-  static TestingFactoryFunction GetDefaultFactory();
-
- private:
-  friend struct base::DefaultSingletonTraits<BookmarkClientFactory>;
-
-  BookmarkClientFactory();
-  ~BookmarkClientFactory() override;
-
-  // BrowserStateKeyedServiceFactory implementation.
-  scoped_ptr<KeyedService> BuildServiceInstanceFor(
-      web::BrowserState* context) const override;
-  web::BrowserState* GetBrowserStateToUse(
-      web::BrowserState* context) const override;
-  bool ServiceIsNULLWhileTesting() const override;
-
-  DISALLOW_COPY_AND_ASSIGN(BookmarkClientFactory);
-};
-
-#endif  // IOS_CHROME_BROWSER_BOOKMARKS_BOOKMARK_CLIENT_FACTORY_H_
diff --git a/ios/chrome/browser/bookmarks/bookmark_model_factory.cc b/ios/chrome/browser/bookmarks/bookmark_model_factory.cc
index e386e8c..d199a67 100644
--- a/ios/chrome/browser/bookmarks/bookmark_model_factory.cc
+++ b/ios/chrome/browser/bookmarks/bookmark_model_factory.cc
@@ -13,7 +13,6 @@
 #include "components/bookmarks/browser/startup_task_runner_service.h"
 #include "components/keyed_service/ios/browser_state_dependency_manager.h"
 #include "components/undo/bookmark_undo_service.h"
-#include "ios/chrome/browser/bookmarks/bookmark_client_factory.h"
 #include "ios/chrome/browser/bookmarks/bookmark_client_impl.h"
 #include "ios/chrome/browser/bookmarks/startup_task_runner_service_factory.h"
 #include "ios/chrome/browser/browser_state/browser_state_otr_helper.h"
@@ -48,7 +47,6 @@ BookmarkModelFactory::BookmarkModelFactory()
     : BrowserStateKeyedServiceFactory(
           "BookmarkModel",
           BrowserStateDependencyManager::GetInstance()) {
-  DependsOn(BookmarkClientFactory::GetInstance());
   DependsOn(ios::BookmarkUndoServiceFactory::GetInstance());
   DependsOn(ios::StartupTaskRunnerServiceFactory::GetInstance());
 }
@@ -64,10 +62,9 @@ scoped_ptr<KeyedService> BookmarkModelFactory::BuildServiceInstanceFor(
     web::BrowserState* context) const {
   ios::ChromeBrowserState* browser_state =
       ios::ChromeBrowserState::FromBrowserState(context);
-  BookmarkClientImpl* bookmark_client =
-      BookmarkClientFactory::GetForBrowserState(browser_state);
   scoped_ptr<bookmarks::BookmarkModel> bookmark_model(
-      new bookmarks::BookmarkModel(bookmark_client));
+      new bookmarks::BookmarkModel(
+          make_scoped_ptr(new BookmarkClientImpl(browser_state))));
   bookmark_model->Load(
       browser_state->GetPrefs(),
       browser_state->GetPrefs()->GetString(prefs::kAcceptLanguages),
diff --git a/ios/chrome/browser/browser_state/browser_state_keyed_service_factories.mm b/ios/chrome/browser/browser_state/browser_state_keyed_service_factories.mm
index 128a221..e7c9cd1 100644
--- a/ios/chrome/browser/browser_state/browser_state_keyed_service_factories.mm
+++ b/ios/chrome/browser/browser_state/browser_state_keyed_service_factories.mm
@@ -8,7 +8,6 @@
 #include "ios/chrome/browser/autocomplete/in_memory_url_index_factory.h"
 #include "ios/chrome/browser/autocomplete/shortcuts_backend_factory.h"
 #include "ios/chrome/browser/autofill/personal_data_manager_factory.h"
-#include "ios/chrome/browser/bookmarks/bookmark_client_factory.h"
 #include "ios/chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "ios/chrome/browser/bookmarks/startup_task_runner_service_factory.h"
 #include "ios/chrome/browser/content_settings/cookie_settings_factory.h"
@@ -54,7 +53,6 @@
 // TODO(erg): This needs to be something else. I don't think putting every
 // FooServiceFactory here will scale or is desirable long term.
 void EnsureBrowserStateKeyedServiceFactoriesBuilt() {
-  BookmarkClientFactory::GetInstance();
   dom_distiller::DomDistillerServiceFactory::GetInstance();
   ios::AboutSigninInternalsFactory::GetInstance();
   ios::AccountConsistencyServiceFactory::GetInstance();
diff --git a/ios/chrome/ios_chrome.gyp b/ios/chrome/ios_chrome.gyp
index 2c918ab..bbedf75 100644
--- a/ios/chrome/ios_chrome.gyp
+++ b/ios/chrome/ios_chrome.gyp
@@ -183,8 +183,6 @@
         'browser/autofill/form_suggestion_view_client.h',
         'browser/autofill/personal_data_manager_factory.cc',
         'browser/autofill/personal_data_manager_factory.h',
-        'browser/bookmarks/bookmark_client_factory.cc',
-        'browser/bookmarks/bookmark_client_factory.h',
         'browser/bookmarks/bookmark_client_impl.cc',
         'browser/bookmarks/bookmark_client_impl.h',
         'browser/bookmarks/bookmark_model_factory.cc',