[Sync] Remove unneeded 'using syncer::' lines and 'syncer::' scopings

sync/engine/process_commit_response_command_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 "sync/engine/process_commit_response_command.h"
 
 #include <vector>
 
 #include "base/location.h"
 #include "base/stringprintf.h"
@@ skipping 32 matching lines @@
 class ProcessCommitResponseCommandTest : public SyncerCommandTest {
  public:
   virtual void SetUp() {
     workers()->clear();
     mutable_routing_info()->clear();
 
     workers()->push_back(
         make_scoped_refptr(new FakeModelWorker(GROUP_DB)));
     workers()->push_back(
         make_scoped_refptr(new FakeModelWorker(GROUP_UI)));
-    (*mutable_routing_info())[syncer::BOOKMARKS] = GROUP_UI;
-    (*mutable_routing_info())[syncer::PREFERENCES] = GROUP_UI;
-    (*mutable_routing_info())[syncer::AUTOFILL] = GROUP_DB;
+    (*mutable_routing_info())[BOOKMARKS] = GROUP_UI;
+    (*mutable_routing_info())[PREFERENCES] = GROUP_UI;
+    (*mutable_routing_info())[AUTOFILL] = GROUP_DB;
 
     SyncerCommandTest::SetUp();
   }
 
  protected:
 
   ProcessCommitResponseCommandTest()
       : next_old_revision_(1),
         next_new_revision_(4000),
         next_server_position_(10000) {
   }
 
   void CheckEntry(Entry* e, const std::string& name,
-                  syncer::ModelType model_type, const Id& parent_id) {
+                  ModelType model_type, const Id& parent_id) {
      EXPECT_TRUE(e->good());
      ASSERT_EQ(name, e->Get(NON_UNIQUE_NAME));
      ASSERT_EQ(model_type, e->GetModelType());
      ASSERT_EQ(parent_id, e->Get(syncable::PARENT_ID));
      ASSERT_LT(0, e->Get(BASE_VERSION))
          << "Item should have a valid (positive) server base revision";
   }
 
   // Create an unsynced item in the database.  If item_id is a local ID, it
   // will be treated as a create-new.  Otherwise, if it's a server ID, we'll
   // fake the server data so that it looks like it exists on the server.
   // Returns the methandle of the created item in |metahandle_out| if not NULL.
   void CreateUnsyncedItem(const Id& item_id,
                           const Id& parent_id,
                           const string& name,
                           bool is_folder,
-                          syncer::ModelType model_type,
+                          ModelType model_type,
                           int64* metahandle_out) {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     Id predecessor_id;
     ASSERT_TRUE(
         directory()->GetLastChildIdForTest(&trans, parent_id, &predecessor_id));
     MutableEntry entry(&trans, syncable::CREATE, parent_id, name);
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::ID, item_id);
     entry.Put(syncable::BASE_VERSION,
         item_id.ServerKnows() ? next_old_revision_++ : 0);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::IS_DIR, is_folder);
     entry.Put(syncable::IS_DEL, false);
     entry.Put(syncable::PARENT_ID, parent_id);
     entry.PutPredecessor(predecessor_id);
     sync_pb::EntitySpecifics default_specifics;
-    syncer::AddDefaultFieldValue(model_type, &default_specifics);
+    AddDefaultFieldValue(model_type, &default_specifics);
     entry.Put(syncable::SPECIFICS, default_specifics);
     if (item_id.ServerKnows()) {
       entry.Put(syncable::SERVER_SPECIFICS, default_specifics);
       entry.Put(syncable::SERVER_IS_DIR, is_folder);
       entry.Put(syncable::SERVER_PARENT_ID, parent_id);
       entry.Put(syncable::SERVER_IS_DEL, false);
     }
     if (metahandle_out)
       *metahandle_out = entry.Get(syncable::META_HANDLE);
   }
 
   // Create a new unsynced item in the database, and synthesize a commit
   // record and a commit response for it in the syncer session.  If item_id
   // is a local ID, the item will be a create operation.  Otherwise, it
   // will be an edit.
   void CreateUnprocessedCommitResult(
       const Id& item_id,
       const Id& parent_id,
       const string& name,
-      syncer::ModelType model_type,
+      ModelType model_type,
       sessions::OrderedCommitSet *commit_set,
       sync_pb::ClientToServerMessage *commit,
       sync_pb::ClientToServerResponse *response) {
     bool is_folder = true;
     int64 metahandle = 0;
     CreateUnsyncedItem(item_id, parent_id, name, is_folder, model_type,
                        &metahandle);
 
     // ProcessCommitResponseCommand consumes commit_ids from the session
     // state, so we need to update that.  O(n^2) because it's a test.
@@ skipping 62 matching lines @@
   sync_pb::ClientToServerMessage request;
   sync_pb::ClientToServerResponse response;
 
   Id bookmark_folder_id = id_factory_.NewLocalId();
   Id bookmark_id1 = id_factory_.NewLocalId();
   Id bookmark_id2 = id_factory_.NewLocalId();
   Id pref_id1 = id_factory_.NewLocalId(), pref_id2 = id_factory_.NewLocalId();
   Id autofill_id1 = id_factory_.NewLocalId();
   Id autofill_id2 = id_factory_.NewLocalId();
   CreateUnprocessedCommitResult(bookmark_folder_id, id_factory_.root(),
-                                "A bookmark folder", syncer::BOOKMARKS,
+                                "A bookmark folder", BOOKMARKS,
                                 &commit_set, &request, &response);
   CreateUnprocessedCommitResult(bookmark_id1, bookmark_folder_id,
-                                "bookmark 1", syncer::BOOKMARKS,
+                                "bookmark 1", BOOKMARKS,
                                 &commit_set, &request, &response);
   CreateUnprocessedCommitResult(bookmark_id2, bookmark_folder_id,
-                                "bookmark 2", syncer::BOOKMARKS,
+                                "bookmark 2", BOOKMARKS,
                                 &commit_set, &request, &response);
   CreateUnprocessedCommitResult(pref_id1, id_factory_.root(),
-                                "Pref 1", syncer::PREFERENCES,
+                                "Pref 1", PREFERENCES,
                                 &commit_set, &request, &response);
   CreateUnprocessedCommitResult(pref_id2, id_factory_.root(),
-                                "Pref 2", syncer::PREFERENCES,
+                                "Pref 2", PREFERENCES,
                                 &commit_set, &request, &response);
   CreateUnprocessedCommitResult(autofill_id1, id_factory_.root(),
-                                "Autofill 1", syncer::AUTOFILL,
+                                "Autofill 1", AUTOFILL,
                                 &commit_set, &request, &response);
   CreateUnprocessedCommitResult(autofill_id2, id_factory_.root(),
-                                "Autofill 2", syncer::AUTOFILL,
+                                "Autofill 2", AUTOFILL,
                                 &commit_set, &request, &response);
 
   ProcessCommitResponseCommand command(commit_set, request, response);
   ExpectGroupsToChange(command, GROUP_UI, GROUP_DB);
   command.ExecuteImpl(session());
 
   syncable::ReadTransaction trans(FROM_HERE, directory());
   Id new_fid;
   ASSERT_TRUE(directory()->GetFirstChildId(
           &trans, id_factory_.root(), &new_fid));
   ASSERT_FALSE(new_fid.IsRoot());
   EXPECT_TRUE(new_fid.ServerKnows());
   EXPECT_FALSE(bookmark_folder_id.ServerKnows());
   EXPECT_FALSE(new_fid == bookmark_folder_id);
   Entry b_folder(&trans, syncable::GET_BY_ID, new_fid);
   ASSERT_TRUE(b_folder.good());
   ASSERT_EQ("A bookmark folder", b_folder.Get(NON_UNIQUE_NAME))
       << "Name of bookmark folder should not change.";
   ASSERT_LT(0, b_folder.Get(BASE_VERSION))
       << "Bookmark folder should have a valid (positive) server base revision";
 
   // Look at the two bookmarks in bookmark_folder.
   Id cid;
   ASSERT_TRUE(directory()->GetFirstChildId(&trans, new_fid, &cid));
   Entry b1(&trans, syncable::GET_BY_ID, cid);
   Entry b2(&trans, syncable::GET_BY_ID, b1.Get(syncable::NEXT_ID));
-  CheckEntry(&b1, "bookmark 1", syncer::BOOKMARKS, new_fid);
-  CheckEntry(&b2, "bookmark 2", syncer::BOOKMARKS, new_fid);
+  CheckEntry(&b1, "bookmark 1", BOOKMARKS, new_fid);
+  CheckEntry(&b2, "bookmark 2", BOOKMARKS, new_fid);
   ASSERT_TRUE(b2.Get(syncable::NEXT_ID).IsRoot());
 
   // Look at the prefs and autofill items.
   Entry p1(&trans, syncable::GET_BY_ID, b_folder.Get(syncable::NEXT_ID));
   Entry p2(&trans, syncable::GET_BY_ID, p1.Get(syncable::NEXT_ID));
-  CheckEntry(&p1, "Pref 1", syncer::PREFERENCES, id_factory_.root());
-  CheckEntry(&p2, "Pref 2", syncer::PREFERENCES, id_factory_.root());
+  CheckEntry(&p1, "Pref 1", PREFERENCES, id_factory_.root());
+  CheckEntry(&p2, "Pref 2", PREFERENCES, id_factory_.root());
 
   Entry a1(&trans, syncable::GET_BY_ID, p2.Get(syncable::NEXT_ID));
   Entry a2(&trans, syncable::GET_BY_ID, a1.Get(syncable::NEXT_ID));
-  CheckEntry(&a1, "Autofill 1", syncer::AUTOFILL, id_factory_.root());
-  CheckEntry(&a2, "Autofill 2", syncer::AUTOFILL, id_factory_.root());
+  CheckEntry(&a1, "Autofill 1", AUTOFILL, id_factory_.root());
+  CheckEntry(&a2, "Autofill 2", AUTOFILL, id_factory_.root());
   ASSERT_TRUE(a2.Get(syncable::NEXT_ID).IsRoot());
 }
 
 // In this test, we test processing a commit response for a commit batch that
 // includes a newly created folder and some (but not all) of its children.
 // In particular, the folder has 50 children, which alternate between being
 // new items and preexisting items.  This mixture of new and old is meant to
 // be a torture test of the code in ProcessCommitResponseCommand that changes
 // an item's ID from a local ID to a server-generated ID on the first commit.
 // We commit only the first 25 children in the sibling order, leaving the
 // second 25 children as unsynced items.  http://crbug.com/33081 describes
 // how this scenario used to fail, reversing the order for the second half
 // of the children.
 TEST_F(ProcessCommitResponseCommandTest, NewFolderCommitKeepsChildOrder) {
   sessions::OrderedCommitSet commit_set(session()->routing_info());
   sync_pb::ClientToServerMessage request;
   sync_pb::ClientToServerResponse response;
 
   // Create the parent folder, a new item whose ID will change on commit.
   Id folder_id = id_factory_.NewLocalId();
   CreateUnprocessedCommitResult(folder_id, id_factory_.root(), "A",
-                                syncer::BOOKMARKS,
+                                BOOKMARKS,
                                 &commit_set, &request, &response);
 
   // Verify that the item is reachable.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Id child_id;
     ASSERT_TRUE(directory()->GetFirstChildId(
             &trans, id_factory_.root(), &child_id));
     ASSERT_EQ(folder_id, child_id);
   }
 
   // The first 25 children of the parent folder will be part of the commit
   // batch.
   int batch_size = 25;
   int i = 0;
   for (; i < batch_size; ++i) {
     // Alternate between new and old child items, just for kicks.
     Id id = (i % 4 < 2) ? id_factory_.NewLocalId() : id_factory_.NewServerId();
     CreateUnprocessedCommitResult(
-        id, folder_id, base::StringPrintf("Item %d", i), syncer::BOOKMARKS,
+        id, folder_id, base::StringPrintf("Item %d", i), BOOKMARKS,
         &commit_set, &request, &response);
   }
   // The second 25 children will be unsynced items but NOT part of the commit
   // batch.  When the ID of the parent folder changes during the commit,
   // these items PARENT_ID should be updated, and their ordering should be
   // preserved.
   for (; i < 2*batch_size; ++i) {
     // Alternate between new and old child items, just for kicks.
     Id id = (i % 4 < 2) ? id_factory_.NewLocalId() : id_factory_.NewServerId();
     CreateUnsyncedItem(id, folder_id, base::StringPrintf("Item %d", i),
-                       false, syncer::BOOKMARKS, NULL);
+                       false, BOOKMARKS, NULL);
   }
 
   // Process the commit response for the parent folder and the first
   // 25 items.  This should apply the values indicated by
   // each CommitResponse_EntryResponse to the syncable Entries.  All new
   // items in the commit batch should have their IDs changed to server IDs.
   ProcessCommitResponseCommand command(commit_set, request, response);
   ExpectGroupToChange(command, GROUP_UI);
   command.ExecuteImpl(session());
 
@@ skipping 73 matching lines @@
                         testing::Range(0, 1 << TEST_PARAM_BIT_COUNT));
 
 // This test commits 2 items (one bookmark, one autofill) and validates what
 // happens to the extensions activity records.  Commits could fail or succeed,
 // depending on the test parameter.
 TEST_P(MixedResult, ExtensionActivity) {
   sessions::OrderedCommitSet commit_set(session()->routing_info());
   sync_pb::ClientToServerMessage request;
   sync_pb::ClientToServerResponse response;
 
-  EXPECT_NE(routing_info().find(syncer::BOOKMARKS)->second,
-            routing_info().find(syncer::AUTOFILL)->second)
+  EXPECT_NE(routing_info().find(BOOKMARKS)->second,
+            routing_info().find(AUTOFILL)->second)
       << "To not be lame, this test requires more than one active group.";
 
   // Bookmark item setup.
   CreateUnprocessedCommitResult(id_factory_.NewServerId(),
-      id_factory_.root(), "Some bookmark", syncer::BOOKMARKS,
+      id_factory_.root(), "Some bookmark", BOOKMARKS,
       &commit_set, &request, &response);
   if (ShouldFailBookmarkCommit())
     SetLastErrorCode(CommitResponse::TRANSIENT_ERROR, &response);
   // Autofill item setup.
   CreateUnprocessedCommitResult(id_factory_.NewServerId(),
-      id_factory_.root(), "Some autofill", syncer::AUTOFILL,
+      id_factory_.root(), "Some autofill", AUTOFILL,
       &commit_set, &request, &response);
   if (ShouldFailAutofillCommit())
     SetLastErrorCode(CommitResponse::TRANSIENT_ERROR, &response);
 
   // Put some extensions activity in the session.
   {
     ExtensionsActivityMonitor::Records* records =
         session()->mutable_extensions_activity();
     (*records)["ABC"].extension_id = "ABC";
     (*records)["ABC"].bookmark_write_count = 2049U;
@@ skipping 14 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer