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

sync/syncable/directory_backing_store.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/syncable/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #include <limits>
 
@@ skipping 33 matching lines @@
 // updating.  Returns the number of args bound.
 void BindFields(const EntryKernel& entry,
                 sql::Statement* statement) {
   int index = 0;
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     statement->BindInt64(index++, entry.ref(static_cast<Int64Field>(i)));
   }
   for ( ; i < TIME_FIELDS_END; ++i) {
     statement->BindInt64(index++,
-                         syncer::TimeToProtoTime(
+                         TimeToProtoTime(
                              entry.ref(static_cast<TimeField>(i))));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     statement->BindString(index++, entry.ref(static_cast<IdField>(i)).s_);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     statement->BindInt(index++, entry.ref(static_cast<BitField>(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     statement->BindString(index++, entry.ref(static_cast<StringField>(i)));
   }
   std::string temp;
   for ( ; i < PROTO_FIELDS_END; ++i) {
     entry.ref(static_cast<ProtoField>(i)).SerializeToString(&temp);
     statement->BindBlob(index++, temp.data(), temp.length());
   }
 }
 
 // The caller owns the returned EntryKernel*.  Assumes the statement currently
 // points to a valid row in the metas table.
 EntryKernel* UnpackEntry(sql::Statement* statement) {
   EntryKernel* kernel = new EntryKernel();
   DCHECK_EQ(statement->ColumnCount(), static_cast<int>(FIELD_COUNT));
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     kernel->put(static_cast<Int64Field>(i), statement->ColumnInt64(i));
   }
   for ( ; i < TIME_FIELDS_END; ++i) {
     kernel->put(static_cast<TimeField>(i),
-                syncer::ProtoTimeToTime(statement->ColumnInt64(i)));
+                ProtoTimeToTime(statement->ColumnInt64(i)));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     kernel->mutable_ref(static_cast<IdField>(i)).s_ =
         statement->ColumnString(i);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     kernel->put(static_cast<BitField>(i), (0 != statement->ColumnInt(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     kernel->put(static_cast<StringField>(i),
@@ skipping 442 matching lines @@
   SafeDropTable("models");
   SafeDropTable("temp_models");
   needs_column_refresh_ = false;
 }
 
 // static
 ModelType DirectoryBackingStore::ModelIdToModelTypeEnum(
     const void* data, int size) {
   sync_pb::EntitySpecifics specifics;
   if (!specifics.ParseFromArray(data, size))
-    return syncer::UNSPECIFIED;
-  return syncer::GetModelTypeFromSpecifics(specifics);
+    return UNSPECIFIED;
+  return GetModelTypeFromSpecifics(specifics);
 }
 
 // static
 string DirectoryBackingStore::ModelTypeEnumToModelId(ModelType model_type) {
   sync_pb::EntitySpecifics specifics;
-  syncer::AddDefaultFieldValue(model_type, &specifics);
+  AddDefaultFieldValue(model_type, &specifics);
   return specifics.SerializeAsString();
 }
 
 // static
 std::string DirectoryBackingStore::GenerateCacheGUID() {
   // Generate a GUID with 128 bits of randomness.
   const int kGuidBytes = 128 / 8;
   std::string guid;
   base::Base64Encode(base::RandBytesAsString(kGuidBytes), &guid);
   return guid;
@@ skipping 425 matching lines @@
 
   if (!CreateModelsTable())
     return false;
 
   // Create the big metas table.
   if (!CreateMetasTable(false))
     return false;
 
   {
     // Insert the entry for the root into the metas table.
-    const int64 now = syncer::TimeToProtoTime(base::Time::Now());
+    const int64 now = TimeToProtoTime(base::Time::Now());
     sql::Statement s(db_->GetUniqueStatement(
             "INSERT INTO metas "
             "( id, metahandle, is_dir, ctime, mtime) "
             "VALUES ( \"r\", 1, 1, ?, ?)"));
     s.BindInt64(0, now);
     s.BindInt64(1, now);
 
     if (!s.Run())
       return false;
   }
@@ skipping 67 matching lines @@
       "store_birthday TEXT, "
       "db_create_version TEXT, "
       "db_create_time INT, "
       "next_id INT default -2, "
       "cache_guid TEXT )");
   return db_->Execute(query.c_str());
 }
 
 }  // namespace syncable
 }  // namespace syncer