Move bookmark_pref_names.* into bookmarks namespace.

chrome/browser/bookmarks/chrome_bookmark_client_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/bookmarks/chrome_bookmark_client.h"
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 16 matching lines @@
 using testing::Mock;
 using testing::_;
 
 class ChromeBookmarkClientTest : public testing::Test {
  public:
   ChromeBookmarkClientTest() : client_(NULL), model_(NULL) {}
   virtual ~ChromeBookmarkClientTest() {}
 
   virtual void SetUp() OVERRIDE {
     prefs_ = profile_.GetTestingPrefService();
-    ASSERT_FALSE(prefs_->HasPrefPath(prefs::kManagedBookmarks));
+    ASSERT_FALSE(prefs_->HasPrefPath(bookmarks::prefs::kManagedBookmarks));
 
-    prefs_->SetManagedPref(prefs::kManagedBookmarks, CreateTestTree());
+    prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
+                           CreateTestTree());
     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()));
   }
 
   virtual void TearDown() OVERRIDE {
     model_->RemoveObserver(&observer_);
@@ skipping 83 matching lines @@
   ChromeBookmarkClient* client_;
   BookmarkModel* model_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeBookmarkClientTest);
 };
 
 TEST_F(ChromeBookmarkClientTest, EmptyManagedNode) {
   // Verifies that the managed node is empty and invisible when the policy is
   // not set.
   model_->RemoveObserver(&observer_);
-  prefs_->RemoveManagedPref(prefs::kManagedBookmarks);
+  prefs_->RemoveManagedPref(bookmarks::prefs::kManagedBookmarks);
   ResetModel();
 
   ASSERT_TRUE(client_->managed_node());
   EXPECT_TRUE(client_->managed_node()->empty());
   EXPECT_FALSE(client_->managed_node()->IsVisible());
 }
 
 TEST_F(ChromeBookmarkClientTest, 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());
 
   scoped_ptr<base::DictionaryValue> expected(CreateExpectedTree());
   EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
 }
 
 TEST_F(ChromeBookmarkClientTest, SwapNodes) {
   // Swap the Google bookmark with the Folder.
   scoped_ptr<base::ListValue> updated(CreateTestTree());
   scoped_ptr<base::Value> removed;
   ASSERT_TRUE(updated->Remove(0, &removed));
   updated->Append(removed.release());
 
   // These two nodes should just be swapped.
   const BookmarkNode* parent = client_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeMoved(model_, parent, 1, parent, 0));
-  prefs_->SetManagedPref(prefs::kManagedBookmarks, updated->DeepCopy());
+  prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
+                         updated->DeepCopy());
   Mock::VerifyAndClearExpectations(&observer_);
 
   // Verify the final tree.
   scoped_ptr<base::DictionaryValue> expected(
       CreateFolder(GetManagedFolderTitle(), updated.release()));
   EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
 }
 
 TEST_F(ChromeBookmarkClientTest, RemoveNode) {
   // Remove the Folder.
   scoped_ptr<base::ListValue> updated(CreateTestTree());
   ASSERT_TRUE(updated->Remove(1, NULL));
 
   const BookmarkNode* parent = client_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 1, _, _));
-  prefs_->SetManagedPref(prefs::kManagedBookmarks, updated->DeepCopy());
+  prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
+                         updated->DeepCopy());
   Mock::VerifyAndClearExpectations(&observer_);
 
   // Verify the final tree.
   scoped_ptr<base::DictionaryValue> expected(
       CreateFolder(GetManagedFolderTitle(), updated.release()));
   EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
 }
 
 TEST_F(ChromeBookmarkClientTest, CreateNewNodes) {
   // Put all the nodes inside another folder.
   scoped_ptr<base::ListValue> updated(new base::ListValue);
   updated->Append(CreateFolder("Container", CreateTestTree()));
 
   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);
-  prefs_->SetManagedPref(prefs::kManagedBookmarks, updated->DeepCopy());
+  prefs_->SetManagedPref(bookmarks::prefs::kManagedBookmarks,
+                         updated->DeepCopy());
   Mock::VerifyAndClearExpectations(&observer_);
 
   // Verify the final tree.
   scoped_ptr<base::DictionaryValue> expected(
       CreateFolder(GetManagedFolderTitle(), updated.release()));
   EXPECT_TRUE(NodeMatchesValue(client_->managed_node(), expected.get()));
 }
 
 TEST_F(ChromeBookmarkClientTest, RemoveAllUserBookmarks) {
   // Remove the policy.
   const BookmarkNode* parent = client_->managed_node();
   EXPECT_CALL(observer_, BookmarkNodeRemoved(model_, parent, 0, _, _))
       .Times(2);
-  prefs_->RemoveManagedPref(prefs::kManagedBookmarks);
+  prefs_->RemoveManagedPref(bookmarks::prefs::kManagedBookmarks);
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_TRUE(client_->managed_node()->empty());
   EXPECT_FALSE(client_->managed_node()->IsVisible());
 }
 
 TEST_F(ChromeBookmarkClientTest, IsDescendantOfManagedNode) {
   EXPECT_FALSE(client_->IsDescendantOfManagedNode(model_->root_node()));
   EXPECT_FALSE(client_->IsDescendantOfManagedNode(model_->bookmark_bar_node()));
   EXPECT_FALSE(client_->IsDescendantOfManagedNode(model_->other_node()));
@@ skipping 42 matching lines @@
   const BookmarkNode* managed_node = client_->managed_node()->GetChild(0);
   ASSERT_TRUE(managed_node);
 
   std::vector<const BookmarkNode*> nodes;
   EXPECT_FALSE(client_->HasDescendantsOfManagedNode(nodes));
   nodes.push_back(user_node);
   EXPECT_FALSE(client_->HasDescendantsOfManagedNode(nodes));
   nodes.push_back(managed_node);
   EXPECT_TRUE(client_->HasDescendantsOfManagedNode(nodes));
 }