[Sync] Move ModelType and related classes to 'syncer' namespace

chrome/browser/sync/profile_sync_service_session_unittest.cc

 // Copyright (c) 2012 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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 270 matching lines @@
   }
 
   virtual ~CreateRootHelper() {}
 
   const base::Closure& callback() const { return callback_; }
   bool success() { return success_; }
 
  private:
   void CreateRootCallback(ProfileSyncServiceSessionTest* test) {
     success_ = ProfileSyncServiceTestHelper::CreateRoot(
-        syncable::SESSIONS, test->sync_service()->GetUserShare(), test->ids());
+        syncer::SESSIONS, test->sync_service()->GetUserShare(), test->ids());
   }
 
   base::Closure callback_;
   bool success_;
 };
 
 // Test that we can write this machine's session to a node and retrieve it.
 TEST_F(ProfileSyncServiceSessionTest, WriteSessionToNode) {
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   ASSERT_TRUE(create_root.success());
 
   // Check that the DataTypeController associated the models.
   bool has_nodes;
   ASSERT_TRUE(model_associator_->SyncModelHasUserCreatedNodes(&has_nodes));
   ASSERT_TRUE(has_nodes);
   std::string machine_tag = model_associator_->GetCurrentMachineTag();
   int64 sync_id = model_associator_->GetSyncIdFromSessionTag(machine_tag);
   ASSERT_NE(syncer::kInvalidId, sync_id);
 
   // Check that we can get the correct session specifics back from the node.
   syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   syncer::ReadNode node(&trans);
   ASSERT_EQ(syncer::BaseNode::INIT_OK,
-            node.InitByClientTagLookup(syncable::SESSIONS, machine_tag));
+            node.InitByClientTagLookup(syncer::SESSIONS, machine_tag));
   const sync_pb::SessionSpecifics& specifics(node.GetSessionSpecifics());
   ASSERT_EQ(machine_tag, specifics.session_tag());
   ASSERT_TRUE(specifics.has_header());
   const sync_pb::SessionHeader& header_s = specifics.header();
   ASSERT_TRUE(header_s.has_device_type());
   ASSERT_EQ("TestSessionName", header_s.client_name());
   ASSERT_EQ(0, header_s.window_size());
 }
 
 // Test that we can fill this machine's session, write it to a node,
@@ skipping 688 matching lines @@
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   syncer::SyncError error;
   std::string local_tag = model_associator_->GetCurrentMachineTag();
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Create a sync node with the local tag but neither header nor tab field.
     syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode root(&trans);
-    root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
+    root.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::SESSIONS));
     syncer::WriteNode extra_header(&trans);
     syncer::WriteNode::InitUniqueByCreationResult result =
-        extra_header.InitUniqueByCreation(syncable::SESSIONS, root, "new_tag");
+        extra_header.InitUniqueByCreation(syncer::SESSIONS, root, "new_tag");
     ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::SessionSpecifics specifics;
     specifics.set_session_tag(local_tag);
     extra_header.SetSessionSpecifics(specifics);
   }
 
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_MultipleHeaders) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   syncer::SyncError error;
   std::string local_tag = model_associator_->GetCurrentMachineTag();
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Create another sync node with a header field and the local tag.
     syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode root(&trans);
-    root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
+    root.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::SESSIONS));
     syncer::WriteNode extra_header(&trans);
     syncer::WriteNode::InitUniqueByCreationResult result =
-        extra_header.InitUniqueByCreation(syncable::SESSIONS,
+        extra_header.InitUniqueByCreation(syncer::SESSIONS,
                                           root, local_tag + "_");
     ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::SessionSpecifics specifics;
     specifics.set_session_tag(local_tag);
     specifics.mutable_header();
     extra_header.SetSessionSpecifics(specifics);
   }
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_CorruptedForeign) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   syncer::SyncError error;
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Create another sync node with neither header nor tab field and a foreign
     // tag.
     std::string foreign_tag = "foreign_tag";
     syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode root(&trans);
-    root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
+    root.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::SESSIONS));
     syncer::WriteNode extra_header(&trans);
     syncer::WriteNode::InitUniqueByCreationResult result =
-        extra_header.InitUniqueByCreation(syncable::SESSIONS,
+        extra_header.InitUniqueByCreation(syncer::SESSIONS,
                                           root, foreign_tag);
     ASSERT_EQ(syncer::WriteNode::INIT_SUCCESS, result);
     sync_pb::SessionSpecifics specifics;
     specifics.set_session_tag(foreign_tag);
     extra_header.SetSessionSpecifics(specifics);
   }
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 // TODO(jhorwich): Re-enable when crbug.com/121487 addressed
 TEST_F(ProfileSyncServiceSessionTest, DISABLED_MissingLocalTabNode) {
   AddTab(browser(), GURL("http://foo1"));
   NavigateAndCommitActiveTab(GURL("http://foo2"));
   AddTab(browser(), GURL("http://bar1"));
   NavigateAndCommitActiveTab(GURL("http://bar2"));
   CreateRootHelper create_root(this);
   ASSERT_TRUE(StartSyncService(create_root.callback(), false));
   std::string local_tag = model_associator_->GetCurrentMachineTag();
   syncer::SyncError error;
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Delete the first sync tab node.
     std::string tab_tag = SessionModelAssociator::TabIdToTag(local_tag, 0);
 
     syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::ReadNode root(&trans);
-    root.InitByTagLookup(syncable::ModelTypeToRootTag(syncable::SESSIONS));
+    root.InitByTagLookup(syncer::ModelTypeToRootTag(syncer::SESSIONS));
     syncer::WriteNode tab_node(&trans);
-    ASSERT_TRUE(tab_node.InitByClientTagLookup(syncable::SESSIONS, tab_tag));
+    ASSERT_TRUE(tab_node.InitByClientTagLookup(syncer::SESSIONS, tab_tag));
     tab_node.Remove();
   }
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 
   // Add some more tabs to ensure we don't conflict with the pre-existing tab
   // node.
   AddTab(browser(), GURL("http://baz1"));
   AddTab(browser(), GURL("http://baz2"));
 }
@@ skipping 49 matching lines @@
   std::string local_tag = model_associator_->GetCurrentMachineTag();
   syncer::SyncError error;
 
   error = model_associator_->DisassociateModels();
   ASSERT_FALSE(error.IsSet());
   {
     // Load the header node and clear it.
     syncer::WriteTransaction trans(FROM_HERE, sync_service_->GetUserShare());
     syncer::WriteNode header(&trans);
     ASSERT_EQ(syncer::BaseNode::INIT_OK,
-              header.InitByClientTagLookup(syncable::SESSIONS, local_tag));
+              header.InitByClientTagLookup(syncer::SESSIONS, local_tag));
     sync_pb::SessionSpecifics specifics;
     header.SetSessionSpecifics(specifics);
   }
   // Ensure we associate properly despite the pre-existing node with our local
   // tag.
   error = model_associator_->AssociateModels();
   ASSERT_FALSE(error.IsSet());
 }
 
 }  // namespace browser_sync