Fix componentization of chrome/browser/bookmarks

Add new class ManagedBookmarkService into //components/bookmarks/managed
responsible for managed and supervised bookmarks creation and policy
enforcement.

BookmarkClient delegates policy decisions to ManagedBookmarkService (and
use sane default if there is no ManagedBookmarkService instance). Remove
all direct access to ChromeBookmarkClient and instead direct queries to
ManagedBookmarkService.

Move prefs registration to a static method of BookmarkModel so that iOS
can reuse it.

BUG=383583,359565

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

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

7 files changed, 269 insertions, 246 deletions

diff --git a/chrome/browser/bookmarks/chrome_bookmark_client.cc b/chrome/browser/bookmarks/chrome_bookmark_client.cc
index 8f11940..671aa64 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client.cc
+++ b/chrome/browser/bookmarks/chrome_bookmark_client.cc
@@ -10,13 +10,11 @@
 #include "base/values.h"
 #include "chrome/browser/favicon/favicon_service_factory.h"
 #include "chrome/browser/history/history_service_factory.h"
-#include "chrome/browser/policy/profile_policy_connector.h"
-#include "chrome/browser/policy/profile_policy_connector_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/browser/bookmark_node.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
-#include "components/bookmarks/managed/managed_bookmarks_tracker.h"
+#include "components/bookmarks/managed/managed_bookmark_service.h"
 #include "components/favicon/core/favicon_service.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/url_database.h"
@@ -28,11 +26,6 @@
 #include "policy/policy_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
-using bookmarks::BookmarkModel;
-using bookmarks::BookmarkNode;
-using bookmarks::BookmarkPermanentNode;
-using bookmarks::ManagedBookmarksTracker;
-
 namespace {
 
 void RunCallbackWithImage(
@@ -49,53 +42,40 @@ void RunCallbackWithImage(
   callback.Run(result);
 }
 
-void LoadInitialContents(BookmarkPermanentNode* node,
-                         base::ListValue* initial_bookmarks,
-                         int64* next_node_id) {
-  // Load the initial contents of the |node| now, and assign it an unused ID.
-  int64 id = *next_node_id;
-  node->set_id(id);
-  *next_node_id = ManagedBookmarksTracker::LoadInitial(
-      node, initial_bookmarks, id + 1);
-  node->set_visible(!node->empty());
+bool IsPermanentNode(
+    const bookmarks::BookmarkPermanentNode* node,
+    bookmarks::ManagedBookmarkService* managed_bookmark_service) {
+  bookmarks::BookmarkNode::Type type = node->type();
+  if (type == bookmarks::BookmarkNode::BOOKMARK_BAR ||
+      type == bookmarks::BookmarkNode::OTHER_NODE ||
+      type == bookmarks::BookmarkNode::MOBILE) {
+    return true;
+  }
+
+  if (!managed_bookmark_service)
+    return false;
+
+  return node == managed_bookmark_service->managed_node() ||
+         node == managed_bookmark_service->supervised_node();
 }
 
 }  // namespace
 
-ChromeBookmarkClient::ChromeBookmarkClient(Profile* profile)
-    : profile_(profile),
-      model_(nullptr),
-      managed_node_(nullptr),
-      supervised_node_(nullptr) {
-}
+ChromeBookmarkClient::ChromeBookmarkClient(
+    Profile* profile,
+    bookmarks::ManagedBookmarkService* managed_bookmark_service)
+    : profile_(profile), managed_bookmark_service_(managed_bookmark_service) {}
 
 ChromeBookmarkClient::~ChromeBookmarkClient() {
 }
 
-void ChromeBookmarkClient::Init(BookmarkModel* model) {
-  DCHECK(model);
-  DCHECK(!model_);
-  model_ = model;
-  model_->AddObserver(this);
-
-  managed_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
-      model_,
-      profile_->GetPrefs(),
-      false,
-      base::Bind(&ChromeBookmarkClient::GetManagedBookmarksDomain,
-                 base::Unretained(this))));
-  supervised_bookmarks_tracker_.reset(new ManagedBookmarksTracker(
-      model_,
-      profile_->GetPrefs(),
-      true,
-      base::Callback<std::string()>()));
+void ChromeBookmarkClient::Init(bookmarks::BookmarkModel* model) {
+  if (managed_bookmark_service_)
+    managed_bookmark_service_->BookmarkModelCreated(model);
 }
 
 void ChromeBookmarkClient::Shutdown() {
-  if (model_) {
-    model_->RemoveObserver(this);
-    model_ = nullptr;
-  }
+  managed_bookmark_service_ = nullptr;
   BookmarkClient::Shutdown();
 }
 
@@ -159,18 +139,17 @@ void ChromeBookmarkClient::GetTypedCountForNodes(
 }
 
 bool ChromeBookmarkClient::IsPermanentNodeVisible(
-    const BookmarkPermanentNode* node) {
-  DCHECK(node->type() == BookmarkNode::BOOKMARK_BAR ||
-         node->type() == BookmarkNode::OTHER_NODE ||
-         node->type() == BookmarkNode::MOBILE ||
-         node == managed_node_ ||
-         node == supervised_node_);
-  if (node == managed_node_ || node == supervised_node_)
+    const bookmarks::BookmarkPermanentNode* node) {
+  DCHECK(IsPermanentNode(node, managed_bookmark_service_));
+  if (managed_bookmark_service_ &&
+      (node == managed_bookmark_service_->managed_node() ||
+       node == managed_bookmark_service_->supervised_node())) {
     return false;
+  }
 #if defined(OS_IOS) || defined(OS_ANDROID)
-  return node->type() == BookmarkNode::MOBILE;
+  return node->type() == bookmarks::BookmarkNode::MOBILE;
 #else
-  return node->type() != BookmarkNode::MOBILE;
+  return node->type() != bookmarks::BookmarkNode::MOBILE;
 #endif
 }
 
@@ -179,89 +158,29 @@ void ChromeBookmarkClient::RecordAction(const base::UserMetricsAction& action) {
 }
 
 bookmarks::LoadExtraCallback ChromeBookmarkClient::GetLoadExtraNodesCallback() {
-  // Create the managed_node_ and supervised_node_ with a temporary ID of 0 now.
-  // They will be populated (and assigned proper IDs) in the LoadExtraNodes
-  // callback.
-  // The ownership of managed_node_ and supervised_node_ is in limbo until
-  // LoadExtraNodes runs, so we leave them in the care of the closure meanwhile.
-  scoped_ptr<BookmarkPermanentNode> managed(new BookmarkPermanentNode(0));
-  managed_node_ = managed.get();
-  scoped_ptr<BookmarkPermanentNode> supervised(new BookmarkPermanentNode(0));
-  supervised_node_ = supervised.get();
+  if (!managed_bookmark_service_)
+    return bookmarks::LoadExtraCallback();
 
-  return base::Bind(
-      &ChromeBookmarkClient::LoadExtraNodes,
-      base::Passed(&managed),
-      base::Passed(managed_bookmarks_tracker_->GetInitialManagedBookmarks()),
-      base::Passed(&supervised),
-      base::Passed(
-          supervised_bookmarks_tracker_->GetInitialManagedBookmarks()));
+  return managed_bookmark_service_->GetLoadExtraNodesCallback();
 }
 
 bool ChromeBookmarkClient::CanSetPermanentNodeTitle(
-    const BookmarkNode* permanent_node) {
-  // The |managed_node_| can have its title updated if the user signs in or
-  // out, since the name of the managed domain can appear in it.
-  // Also, both |managed_node_| and |supervised_node_| can have their title
-  // updated on locale changes (crbug.com/459448).
-  return (!bookmarks::IsDescendantOf(permanent_node, managed_node_) &&
-          !bookmarks::IsDescendantOf(permanent_node, supervised_node_)) ||
-         permanent_node == managed_node_ ||
-         permanent_node == supervised_node_;
-}
-
-bool ChromeBookmarkClient::CanSyncNode(const BookmarkNode* node) {
-  return !bookmarks::IsDescendantOf(node, managed_node_) &&
-         !bookmarks::IsDescendantOf(node, supervised_node_);
-}
-
-bool ChromeBookmarkClient::CanBeEditedByUser(const BookmarkNode* node) {
-  return !bookmarks::IsDescendantOf(node, managed_node_) &&
-         !bookmarks::IsDescendantOf(node, supervised_node_);
-}
-
-void ChromeBookmarkClient::BookmarkModelChanged() {
+    const bookmarks::BookmarkNode* permanent_node) {
+  return !managed_bookmark_service_
+             ? true
+             : managed_bookmark_service_->CanSetPermanentNodeTitle(
+                   permanent_node);
 }
 
-void ChromeBookmarkClient::BookmarkModelLoaded(BookmarkModel* model,
-                                               bool ids_reassigned) {
-  BaseBookmarkModelObserver::BookmarkModelLoaded(model, ids_reassigned);
-  // Start tracking the managed and supervised bookmarks. This will detect any
-  // changes that may have occurred while the initial managed and supervised
-  // bookmarks were being loaded on the background.
-  managed_bookmarks_tracker_->Init(managed_node_);
-  supervised_bookmarks_tracker_->Init(supervised_node_);
-}
-
-// static
-bookmarks::BookmarkPermanentNodeList ChromeBookmarkClient::LoadExtraNodes(
-    scoped_ptr<BookmarkPermanentNode> managed_node,
-    scoped_ptr<base::ListValue> initial_managed_bookmarks,
-    scoped_ptr<BookmarkPermanentNode> supervised_node,
-    scoped_ptr<base::ListValue> initial_supervised_bookmarks,
-    int64* next_node_id) {
-  LoadInitialContents(
-      managed_node.get(), initial_managed_bookmarks.get(), next_node_id);
-  managed_node->SetTitle(l10n_util::GetStringUTF16(
-      IDS_BOOKMARK_BAR_MANAGED_FOLDER_DEFAULT_NAME));
-
-  LoadInitialContents(
-      supervised_node.get(), initial_supervised_bookmarks.get(), next_node_id);
-  supervised_node->SetTitle(l10n_util::GetStringUTF16(
-      IDS_BOOKMARK_BAR_SUPERVISED_FOLDER_DEFAULT_NAME));
-
-  bookmarks::BookmarkPermanentNodeList extra_nodes;
-  // Ownership of the managed and supervised nodes passed to the caller.
-  extra_nodes.push_back(managed_node.release());
-  extra_nodes.push_back(supervised_node.release());
-
-  return extra_nodes.Pass();
+bool ChromeBookmarkClient::CanSyncNode(const bookmarks::BookmarkNode* node) {
+  return !managed_bookmark_service_
+             ? true
+             : managed_bookmark_service_->CanSyncNode(node);
 }
 
-std::string ChromeBookmarkClient::GetManagedBookmarksDomain() {
-  policy::ProfilePolicyConnector* connector =
-      policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile_);
-  if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks))
-    return connector->GetManagementDomain();
-  return std::string();
+bool ChromeBookmarkClient::CanBeEditedByUser(
+    const bookmarks::BookmarkNode* node) {
+  return !managed_bookmark_service_
+             ? true
+             : managed_bookmark_service_->CanBeEditedByUser(node);
 }
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client.h b/chrome/browser/bookmarks/chrome_bookmark_client.h
index 683ebeb..3fdde2c 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client.h
+++ b/chrome/browser/bookmarks/chrome_bookmark_client.h
@@ -10,7 +10,6 @@
 
 #include "base/deferred_sequenced_task_runner.h"
 #include "base/macros.h"
-#include "components/bookmarks/browser/base_bookmark_model_observer.h"
 #include "components/bookmarks/browser/bookmark_client.h"
 
 class GURL;
@@ -24,13 +23,14 @@ namespace bookmarks {
 class BookmarkModel;
 class BookmarkNode;
 class BookmarkPermanentNode;
-class ManagedBookmarksTracker;
+class ManagedBookmarkService;
 }
 
-class ChromeBookmarkClient : public bookmarks::BookmarkClient,
-                             public bookmarks::BaseBookmarkModelObserver {
+class ChromeBookmarkClient : public bookmarks::BookmarkClient {
  public:
-  explicit ChromeBookmarkClient(Profile* profile);
+  ChromeBookmarkClient(
+      Profile* profile,
+      bookmarks::ManagedBookmarkService* managed_bookmark_service);
   ~ChromeBookmarkClient() override;
 
   void Init(bookmarks::BookmarkModel* model);
@@ -38,12 +38,6 @@ class ChromeBookmarkClient : public bookmarks::BookmarkClient,
   // KeyedService:
   void Shutdown() override;
 
-  // The top-level managed bookmarks folder, defined by an enterprise policy.
-  const bookmarks::BookmarkNode* managed_node() { return managed_node_; }
-  // The top-level supervised bookmarks folder, defined by the custodian of a
-  // supervised user.
-  const bookmarks::BookmarkNode* supervised_node() { return supervised_node_; }
-
   // bookmarks::BookmarkClient:
   bool PreferTouchIcon() override;
   base::CancelableTaskTracker::TaskId GetFaviconImageForPageURL(
@@ -65,40 +59,12 @@ class ChromeBookmarkClient : public bookmarks::BookmarkClient,
   bool CanBeEditedByUser(const bookmarks::BookmarkNode* node) override;
 
  private:
-  // bookmarks::BaseBookmarkModelObserver:
-  void BookmarkModelChanged() override;
-
-  // bookmarks::BookmarkModelObserver:
-  void BookmarkModelLoaded(bookmarks::BookmarkModel* model,
-                           bool ids_reassigned) override;
-
-  // Helper for GetLoadExtraNodesCallback().
-  static bookmarks::BookmarkPermanentNodeList LoadExtraNodes(
-      scoped_ptr<bookmarks::BookmarkPermanentNode> managed_node,
-      scoped_ptr<base::ListValue> initial_managed_bookmarks,
-      scoped_ptr<bookmarks::BookmarkPermanentNode> supervised_node,
-      scoped_ptr<base::ListValue> initial_supervised_bookmarks,
-      int64* next_node_id);
-
-  // Returns the management domain that configured the managed bookmarks,
-  // or an empty string.
-  std::string GetManagedBookmarksDomain();
-
+  // Pointer to the associated Profile. Must outlive ChromeBookmarkClient.
   Profile* profile_;
 
-  // Pointer to the BookmarkModel. Will be non-NULL from the call to Init to
-  // the call to Shutdown. Must be valid for the whole interval.
-  bookmarks::BookmarkModel* model_;
-
-  // Managed bookmarks are defined by an enterprise policy.
-  scoped_ptr<bookmarks::ManagedBookmarksTracker> managed_bookmarks_tracker_;
-  // The top-level managed bookmarks folder.
-  bookmarks::BookmarkPermanentNode* managed_node_;
-
-  // Supervised bookmarks are defined by the custodian of a supervised user.
-  scoped_ptr<bookmarks::ManagedBookmarksTracker> supervised_bookmarks_tracker_;
-  // The top-level supervised bookmarks folder.
-  bookmarks::BookmarkPermanentNode* supervised_node_;
+  // Pointer to the ManagedBookmarkService responsible for bookmark policy. May
+  // be null during testing.
+  bookmarks::ManagedBookmarkService* managed_bookmark_service_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeBookmarkClient);
 };
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc b/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc
index b97488f..2626f78 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc
+++ b/chrome/browser/bookmarks/chrome_bookmark_client_factory.cc
@@ -6,10 +6,23 @@
 
 #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) {
@@ -22,10 +35,17 @@ ChromeBookmarkClientFactory* ChromeBookmarkClientFactory::GetInstance() {
   return Singleton<ChromeBookmarkClientFactory>::get();
 }
 
+// static
+BrowserContextKeyedServiceFactory::TestingFactoryFunction
+ChromeBookmarkClientFactory::GetDefaultFactory() {
+  return &BuildChromeBookmarkClient;
+}
+
 ChromeBookmarkClientFactory::ChromeBookmarkClientFactory()
     : BrowserContextKeyedServiceFactory(
           "ChromeBookmarkClient",
           BrowserContextDependencyManager::GetInstance()) {
+  DependsOn(ManagedBookmarkServiceFactory::GetInstance());
 }
 
 ChromeBookmarkClientFactory::~ChromeBookmarkClientFactory() {
@@ -33,7 +53,7 @@ ChromeBookmarkClientFactory::~ChromeBookmarkClientFactory() {
 
 KeyedService* ChromeBookmarkClientFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
-  return new ChromeBookmarkClient(static_cast<Profile*>(context));
+  return BuildChromeBookmarkClient(context).release();
 }
 
 content::BrowserContext* ChromeBookmarkClientFactory::GetBrowserContextToUse(
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_factory.h b/chrome/browser/bookmarks/chrome_bookmark_client_factory.h
index 597728bb..a5971f6 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client_factory.h
+++ b/chrome/browser/bookmarks/chrome_bookmark_client_factory.h
@@ -19,8 +19,8 @@ class Profile;
 class ChromeBookmarkClientFactory : public BrowserContextKeyedServiceFactory {
  public:
   static ChromeBookmarkClient* GetForProfile(Profile* profile);
-
   static ChromeBookmarkClientFactory* GetInstance();
+  static TestingFactoryFunction GetDefaultFactory();
 
  private:
   friend struct DefaultSingletonTraits<ChromeBookmarkClientFactory>;
diff --git a/chrome/browser/bookmarks/managed_bookmark_service_factory.cc b/chrome/browser/bookmarks/managed_bookmark_service_factory.cc
new file mode 100644
index 0000000..ffeafb3
--- /dev/null
+++ b/chrome/browser/bookmarks/managed_bookmark_service_factory.cc
@@ -0,0 +1,78 @@
+// 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 "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "base/memory/singleton.h"
+#include "chrome/browser/policy/profile_policy_connector.h"
+#include "chrome/browser/policy/profile_policy_connector_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"
+#include "policy/policy_constants.h"
+
+namespace {
+
+std::string GetManagedBookmarksDomain(Profile* profile) {
+  policy::ProfilePolicyConnector* connector =
+      policy::ProfilePolicyConnectorFactory::GetForBrowserContext(profile);
+  if (connector->IsPolicyFromCloudPolicy(policy::key::kManagedBookmarks))
+    return connector->GetManagementDomain();
+  return std::string();
+}
+
+scoped_ptr<KeyedService> BuildManagedBookmarkService(
+    content::BrowserContext* context) {
+  Profile* profile = Profile::FromBrowserContext(context);
+  return make_scoped_ptr(new bookmarks::ManagedBookmarkService(
+      profile->GetPrefs(),
+      base::Bind(&GetManagedBookmarksDomain, base::Unretained(profile))));
+}
+
+}  // namespace
+
+// static
+bookmarks::ManagedBookmarkService* ManagedBookmarkServiceFactory::GetForProfile(
+    Profile* profile) {
+  return static_cast<bookmarks::ManagedBookmarkService*>(
+      GetInstance()->GetServiceForBrowserContext(profile, true));
+}
+
+// static
+ManagedBookmarkServiceFactory* ManagedBookmarkServiceFactory::GetInstance() {
+  return Singleton<ManagedBookmarkServiceFactory>::get();
+}
+
+// static
+BrowserContextKeyedServiceFactory::TestingFactoryFunction
+ManagedBookmarkServiceFactory::GetDefaultFactory() {
+  return &BuildManagedBookmarkService;
+}
+
+ManagedBookmarkServiceFactory::ManagedBookmarkServiceFactory()
+    : BrowserContextKeyedServiceFactory(
+          "ManagedBookmarkService",
+          BrowserContextDependencyManager::GetInstance()) {
+  DependsOn(policy::ProfilePolicyConnectorFactory::GetInstance());
+}
+
+ManagedBookmarkServiceFactory::~ManagedBookmarkServiceFactory() {}
+
+KeyedService* ManagedBookmarkServiceFactory::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  return BuildManagedBookmarkService(context).release();
+}
+
+content::BrowserContext* ManagedBookmarkServiceFactory::GetBrowserContextToUse(
+    content::BrowserContext* context) const {
+  return chrome::GetBrowserContextRedirectedInIncognito(context);
+}
+
+bool ManagedBookmarkServiceFactory::ServiceIsNULLWhileTesting() const {
+  return true;
+}
diff --git a/chrome/browser/bookmarks/managed_bookmark_service_factory.h b/chrome/browser/bookmarks/managed_bookmark_service_factory.h
new file mode 100644
index 0000000..af1e102
--- /dev/null
+++ b/chrome/browser/bookmarks/managed_bookmark_service_factory.h
@@ -0,0 +1,44 @@
+// 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 CHROME_BROWSER_BOOKMARKS_MANAGED_BOOKMARK_SERVICE_FACTORY_H_
+#define CHROME_BROWSER_BOOKMARKS_MANAGED_BOOKMARK_SERVICE_FACTORY_H_
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "components/keyed_service/content/browser_context_keyed_service_factory.h"
+
+template <typename T>
+struct DefaultSingletonTraits;
+class Profile;
+
+namespace bookmarks {
+class ManagedBookmarkService;
+}
+
+// Singleton that owns all ManagedBookmarkServices and associates them with
+// Profile.
+class ManagedBookmarkServiceFactory : public BrowserContextKeyedServiceFactory {
+ public:
+  static bookmarks::ManagedBookmarkService* GetForProfile(Profile* profile);
+  static ManagedBookmarkServiceFactory* GetInstance();
+  static TestingFactoryFunction GetDefaultFactory();
+
+ private:
+  friend struct DefaultSingletonTraits<ManagedBookmarkServiceFactory>;
+
+  ManagedBookmarkServiceFactory();
+  ~ManagedBookmarkServiceFactory() override;
+
+  // BrowserStateKeyedServiceFactory implementation.
+  KeyedService* BuildServiceInstanceFor(
+      content::BrowserContext* context) const override;
+  content::BrowserContext* GetBrowserContextToUse(
+      content::BrowserContext* context) const override;
+  bool ServiceIsNULLWhileTesting() const override;
+
+  DISALLOW_COPY_AND_ASSIGN(ManagedBookmarkServiceFactory);
+};
+
+#endif  // CHROME_BROWSER_BOOKMARKS_MANAGED_BOOKMARK_SERVICE_FACTORY_H_
diff --git a/chrome/browser/bookmarks/chrome_bookmark_client_unittest.cc b/chrome/browser/bookmarks/managed_bookmark_service_unittest.cc
index 6a6dd17..b37ccaa 100644
--- a/chrome/browser/bookmarks/chrome_bookmark_client_unittest.cc
+++ b/chrome/browser/bookmarks/managed_bookmark_service_unittest.cc
@@ -2,7 +2,7 @@
 // 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.h"
+#include "components/bookmarks/managed/managed_bookmark_service.h"
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ -10,7 +10,7 @@
 #include "base/values.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/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/bookmarks/browser/bookmark_model.h"
@@ -27,13 +27,14 @@
 
 using bookmarks::BookmarkModel;
 using bookmarks::BookmarkNode;
+using bookmarks::ManagedBookmarkService;
 using testing::Mock;
 using testing::_;
 
-class ChromeBookmarkClientTest : public testing::Test {
+class ManagedBookmarkServiceTest : public testing::Test {
  public:
-  ChromeBookmarkClientTest() : client_(NULL), model_(NULL) {}
-  ~ChromeBookmarkClientTest() override {}
+  ManagedBookmarkServiceTest() : managed_(NULL), model_(NULL) {}
+  ~ManagedBookmarkServiceTest() override {}
 
   void SetUp() override {
     prefs_ = profile_.GetTestingPrefService();
@@ -44,9 +45,9 @@ class ChromeBookmarkClientTest : public testing::Test {
     ResetModel();
 
     // The managed node always exists.
-    ASSERT_TRUE(client_->managed_node());
-    ASSERT_TRUE(client_->managed_node()->parent() == model_->root_node());
-    EXPECT_NE(-1, model_->root_node()->GetIndexOf(client_->managed_node()));
+    ASSERT_TRUE(managed_->managed_node());
+    ASSERT_TRUE(managed_->managed_node()->parent() == model_->root_node());
+    EXPECT_NE(-1, model_->root_node()->GetIndexOf(managed_->managed_node()));
   }
 
   void TearDown() override { model_->RemoveObserver(&observer_); }
@@ -56,8 +57,8 @@ class ChromeBookmarkClientTest : public testing::Test {
     model_ = BookmarkModelFactory::GetForProfile(&profile_);
     bookmarks::test::WaitForBookmarkModelToLoad(model_);
     model_->AddObserver(&observer_);
-    client_ = ChromeBookmarkClientFactory::GetForProfile(&profile_);
-    DCHECK(client_);
+    managed_ = ManagedBookmarkServiceFactory::GetForProfile(&profile_);
+    DCHECK(managed_);
   }
 
   static base::DictionaryValue* CreateBookmark(const std::string& title,
@@ -132,36 +133,36 @@ class ChromeBookmarkClientTest : public testing::Test {
   TestingProfile profile_;
   TestingPrefServiceSyncable* prefs_;
   bookmarks::MockBookmarkModelObserver observer_;
-  ChromeBookmarkClient* client_;
+  ManagedBookmarkService* managed_;
   BookmarkModel* model_;
 
-  DISALLOW_COPY_AND_ASSIGN(ChromeBookmarkClientTest);
+  DISALLOW_COPY_AND_ASSIGN(ManagedBookmarkServiceTest);
 };
 
-TEST_F(ChromeBookmarkClientTest, EmptyManagedNode) {
+TEST_F(ManagedBookmarkServiceTest, EmptyManagedNode) {
   // Verifies that the managed node is empty and invisible when the policy is
   // not set.
   model_->RemoveObserver(&observer_);
   prefs_->RemoveManagedPref(bookmarks::prefs::kManagedBookmarks);
   ResetModel();
 
-  ASSERT_TRUE(client_->managed_node());
-  EXPECT_TRUE(client_->managed_node()->empty());
-  EXPECT_FALSE(client_->managed_node()->IsVisible());
+  ASSERT_TRUE(managed_->managed_node());
+  EXPECT_TRUE(managed_->managed_node()->empty());
+  EXPECT_FALSE(managed_->managed_node()->IsVisible());
 }
 
-TEST_F(ChromeBookmarkClientTest, LoadInitial) {
+TEST_F(ManagedBookmarkServiceTest, LoadInitial) {
   // Verifies that the initial load picks up the initial policy too.
   EXPECT_TRUE(model_->bookmark_bar_node()->empty());
   EXPECT_TRUE(model_->other_node()->empty());
-  EXPECT_FALSE(client_->managed_node()->empty());
-  EXPECT_TRUE(client_->managed_node()->IsVisible());
+  EXPECT_FALSE(managed_->managed_node()->empty());
+  EXPECT_TRUE(managed_->managed_node()->IsVisible());
 
   scoped_ptr<base::DictionaryValue> expected(CreateExpectedTree());
-  EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
+  EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get()));
 }
 
-TEST_F(ChromeBookmarkClientTest, SwapNodes) {
+TEST_F(ManagedBookmarkServiceTest, SwapNodes) {
   // Swap the Google bookmark with the Folder.
   scoped_ptr<base::ListValue> updated(CreateTestTree());
   scoped_ptr<base::Value> removed;
@@ -169,7 +170,7 @@ TEST_F(ChromeBookmarkClientTest, SwapNodes) {
   updated->Append(removed.release());
 
   // These two nodes should just be swapped.
-  const BookmarkNode* parent = client_->managed_node();
+  const BookmarkNode* parent = managed_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeMoved(model_, parent, 1, parent, 0));
   prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
                          updated->DeepCopy());
@@ -178,15 +179,15 @@ TEST_F(ChromeBookmarkClientTest, SwapNodes) {
   // Verify the final tree.
   scoped_ptr<base::DictionaryValue> expected(
       CreateFolder(GetManagedFolderTitle(), updated.release()));
-  EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
+  EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get()));
 }
 
-TEST_F(ChromeBookmarkClientTest, RemoveNode) {
+TEST_F(ManagedBookmarkServiceTest, RemoveNode) {
   // Remove the Folder.
   scoped_ptr<base::ListValue> updated(CreateTestTree());
   ASSERT_TRUE(updated->Remove(1, NULL));
 
-  const BookmarkNode* parent = client_->managed_node();
+  const BookmarkNode* parent = managed_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _));
   prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
                          updated->DeepCopy());
@@ -195,10 +196,10 @@ TEST_F(ChromeBookmarkClientTest, RemoveNode) {
   // Verify the final tree.
   scoped_ptr<base::DictionaryValue> expected(
       CreateFolder(GetManagedFolderTitle(), updated.release()));
-  EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
+  EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get()));
 }
 
-TEST_F(ChromeBookmarkClientTest, CreateNewNodes) {
+TEST_F(ManagedBookmarkServiceTest, CreateNewNodes) {
   // Put all the nodes inside another folder.
   scoped_ptr<base::ListValue> updated(new base::ListValue);
   updated->Append(CreateFolder("Container", CreateTestTree()));
@@ -206,9 +207,8 @@ TEST_F(ChromeBookmarkClientTest, CreateNewNodes) {
   EXPECT_CALL(observer_, BookmarkNodeAdded(model_, _, _)).Times(5);
   // The remaining nodes have been pushed to positions 1 and 2; they'll both be
   // removed when at position 1.
-  const BookmarkNode* parent = client_->managed_node();
-  EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _))
-      .Times(2);
+  const BookmarkNode* parent = managed_->managed_node();
+  EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _)).Times(2);
   prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
                          updated->DeepCopy());
   Mock::VerifyAndClearExpectations(&observer_);
@@ -216,83 +216,79 @@ TEST_F(ChromeBookmarkClientTest, CreateNewNodes) {
   // Verify the final tree.
   scoped_ptr<base::DictionaryValue> expected(
       CreateFolder(GetManagedFolderTitle(), updated.release()));
-  EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
+  EXPECT_TRUE(NodeMatchesValue(managed_->managed_node(), expected.get()));
 }
 
-TEST_F(ChromeBookmarkClientTest, RemoveAllUserBookmarks) {
+TEST_F(ManagedBookmarkServiceTest, RemoveAllUserBookmarks) {
   // Remove the policy.
-  const BookmarkNode* parent = client_->managed_node();
-  EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 0, _, _))
-      .Times(2);
+  const BookmarkNode* parent = managed_->managed_node();
+  EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 0, _, _)).Times(2);
   prefs_->RemoveManagedPref(bookmarks::prefs::kManagedBookmarks);
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_TRUE(client_->managed_node()->empty());
-  EXPECT_FALSE(client_->managed_node()->IsVisible());
+  EXPECT_TRUE(managed_->managed_node()->empty());
+  EXPECT_FALSE(managed_->managed_node()->IsVisible());
 }
 
-TEST_F(ChromeBookmarkClientTest, IsDescendantOfManagedNode) {
-  EXPECT_FALSE(bookmarks::IsDescendantOf(model_->root_node(),
-                                         client_->managed_node()));
+TEST_F(ManagedBookmarkServiceTest, IsDescendantOfManagedNode) {
+  EXPECT_FALSE(
+      bookmarks::IsDescendantOf(model_->root_node(), managed_->managed_node()));
   EXPECT_FALSE(bookmarks::IsDescendantOf(model_->bookmark_bar_node(),
-                                         client_->managed_node()));
+                                         managed_->managed_node()));
   EXPECT_FALSE(bookmarks::IsDescendantOf(model_->other_node(),
-                                         client_->managed_node()));
+                                         managed_->managed_node()));
   EXPECT_FALSE(bookmarks::IsDescendantOf(model_->mobile_node(),
-                                         client_->managed_node()));
-  EXPECT_TRUE(bookmarks::IsDescendantOf(client_->managed_node(),
-                                        client_->managed_node()));
+                                         managed_->managed_node()));
+  EXPECT_TRUE(bookmarks::IsDescendantOf(managed_->managed_node(),
+                                        managed_->managed_node()));
 
-  const BookmarkNode* parent = client_->managed_node();
+  const BookmarkNode* parent = managed_->managed_node();
   ASSERT_EQ(2, parent->child_count());
-  EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(0),
-                                        client_->managed_node()));
-  EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(1),
-                                        client_->managed_node()));
+  EXPECT_TRUE(
+      bookmarks::IsDescendantOf(parent->GetChild(0), managed_->managed_node()));
+  EXPECT_TRUE(
+      bookmarks::IsDescendantOf(parent->GetChild(1), managed_->managed_node()));
 
   parent = parent->GetChild(1);
   ASSERT_EQ(2, parent->child_count());
-  EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(0),
-                                        client_->managed_node()));
-  EXPECT_TRUE(bookmarks::IsDescendantOf(parent->GetChild(1),
-                                        client_->managed_node()));
+  EXPECT_TRUE(
+      bookmarks::IsDescendantOf(parent->GetChild(0), managed_->managed_node()));
+  EXPECT_TRUE(
+      bookmarks::IsDescendantOf(parent->GetChild(1), managed_->managed_node()));
 }
 
-TEST_F(ChromeBookmarkClientTest, RemoveAllDoesntRemoveManaged) {
-  EXPECT_EQ(2, client_->managed_node()->child_count());
+TEST_F(ManagedBookmarkServiceTest, RemoveAllDoesntRemoveManaged) {
+  EXPECT_EQ(2, managed_->managed_node()->child_count());
 
   EXPECT_CALL(observer_,
               BookmarkNodeAdded(model_, model_->bookmark_bar_node(), 0));
   EXPECT_CALL(observer_,
               BookmarkNodeAdded(model_, model_->bookmark_bar_node(), 1));
-  model_->AddURL(model_->bookmark_bar_node(),
-                 0,
-                 base::ASCIIToUTF16("Test"),
+  model_->AddURL(model_->bookmark_bar_node(), 0, base::ASCIIToUTF16("Test"),
                  GURL("http://google.com/"));
-  model_->AddFolder(
-      model_->bookmark_bar_node(), 1, base::ASCIIToUTF16("Test Folder"));
+  model_->AddFolder(model_->bookmark_bar_node(), 1,
+                    base::ASCIIToUTF16("Test Folder"));
   EXPECT_EQ(2, model_->bookmark_bar_node()->child_count());
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(observer_, BookmarkAllUserNodesRemoved(model_, _));
   model_->RemoveAllUserBookmarks();
-  EXPECT_EQ(2, client_->managed_node()->child_count());
+  EXPECT_EQ(2, managed_->managed_node()->child_count());
   EXPECT_EQ(0, model_->bookmark_bar_node()->child_count());
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
-TEST_F(ChromeBookmarkClientTest, HasDescendantsOfManagedNode) {
-  const BookmarkNode* user_node = model_->AddURL(model_->other_node(),
-                                                 0,
-                                                 base::ASCIIToUTF16("foo bar"),
-                                                 GURL("http://www.google.com"));
-  const BookmarkNode* managed_node = client_->managed_node()->GetChild(0);
+TEST_F(ManagedBookmarkServiceTest, HasDescendantsOfManagedNode) {
+  const BookmarkNode* user_node =
+      model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("foo bar"),
+                     GURL("http://www.google.com"));
+  const BookmarkNode* managed_node = managed_->managed_node()->GetChild(0);
   ASSERT_TRUE(managed_node);
 
   std::vector<const BookmarkNode*> nodes;
-  EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, client_->managed_node()));
+  EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node()));
   nodes.push_back(user_node);
-  EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, client_->managed_node()));
+  EXPECT_FALSE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node()));
   nodes.push_back(managed_node);
-  EXPECT_TRUE(bookmarks::HasDescendantsOf(nodes, client_->managed_node()));
+  EXPECT_TRUE(bookmarks::HasDescendantsOf(nodes, managed_->managed_node()));
 }