[Sync] Move //components/sync to the syncer namespace, take 2.

components/sync/core/shared_model_type_processor_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 "components/sync/core/shared_model_type_processor.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 14 matching lines @@
 #include "components/sync/core/simple_metadata_change_list.h"
 #include "components/sync/engine/commit_queue.h"
 #include "components/sync/protocol/sync.pb.h"
 #include "components/sync/test/engine/mock_model_type_worker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using sync_pb::EntitySpecifics;
 using sync_pb::EntityMetadata;
 using sync_pb::DataTypeState;
 
-namespace syncer_v2 {
+namespace syncer {
 
 namespace {
 
 const char kKey1[] = "key1";
 const char kKey2[] = "key2";
 const char kKey3[] = "key3";
 const char kKey4[] = "key4";
 const char kKey5[] = "key5";
 const char kValue1[] = "value1";
 const char kValue2[] = "value2";
 const char kValue3[] = "value3";
 const std::string kHash1(FakeModelTypeService::TagHashFromKey(kKey1));
 const std::string kHash2(FakeModelTypeService::TagHashFromKey(kKey2));
 const std::string kHash3(FakeModelTypeService::TagHashFromKey(kKey3));
 const std::string kHash4(FakeModelTypeService::TagHashFromKey(kKey4));
 const std::string kHash5(FakeModelTypeService::TagHashFromKey(kKey5));
 
 // Typically used for verification after a delete. The specifics given to the
 // worker/processor will not have been initialized and thus empty.
 const EntitySpecifics kEmptySpecifics;
 
-syncer::SyncError CreateSyncError(syncer::SyncError::ErrorType error_type) {
-  return syncer::SyncError(FROM_HERE, error_type, "TestError",
-                           syncer::PREFERENCES);
+SyncError CreateSyncError(SyncError::ErrorType error_type) {
+  return SyncError(FROM_HERE, error_type, "TestError", PREFERENCES);
 }
 
 }  // namespace
 
 // Tests the various functionality of SharedModelTypeProcessor.
 //
 // The processor sits between the service (implemented by this test class) and
 // the worker, which is represented by a MockModelTypeWorker. This test suite
 // exercises the initialization flows (whether initial sync is done, performing
 // the initial merge, etc) as well as normal functionality:
@@ skipping 24 matching lines @@
   // Initialize to a "ready-to-commit" state.
   void InitializeToReadyState() {
     InitializeToMetadataLoaded();
     if (!data_callback_.is_null()) {
       OnPendingCommitDataLoaded();
     }
     OnSyncStarting();
   }
 
   void OnMetadataLoaded() {
-    type_processor()->OnMetadataLoaded(syncer::SyncError(),
-                                       db_.CreateMetadataBatch());
+    type_processor()->OnMetadataLoaded(SyncError(), db_.CreateMetadataBatch());
   }
 
   void OnPendingCommitDataLoaded() {
     DCHECK(!data_callback_.is_null());
     data_callback_.Run();
     data_callback_.Reset();
   }
 
   void OnSyncStarting() {
-    std::unique_ptr<syncer::DataTypeErrorHandlerMock> error_handler =
-        base::MakeUnique<syncer::DataTypeErrorHandlerMock>();
+    std::unique_ptr<DataTypeErrorHandlerMock> error_handler =
+        base::MakeUnique<DataTypeErrorHandlerMock>();
     error_handler_ = error_handler.get();
     type_processor()->OnSyncStarting(
         std::move(error_handler),
         base::Bind(&SharedModelTypeProcessorTest::OnReadyToConnect,
                    base::Unretained(this)));
   }
 
   void DisconnectSync() {
     type_processor()->DisconnectSync();
     worker_ = nullptr;
@@ skipping 44 matching lines @@
   }
 
   // Return the number of entities the processor has metadata for.
   size_t ProcessorEntityCount() const {
     DCHECK(type_processor());
     return type_processor()->entities_.size();
   }
 
   // Sets the error type that OnReadyToConnect (our StartCallback) expects to
   // receive.
-  void ExpectStartError(syncer::SyncError::ErrorType error_type) {
-    DCHECK(expected_start_error_ == syncer::SyncError::UNSET);
+  void ExpectStartError(SyncError::ErrorType error_type) {
+    DCHECK(expected_start_error_ == SyncError::UNSET);
     expected_start_error_ = error_type;
   }
 
   MockModelTypeWorker* worker() { return worker_; }
 
   SharedModelTypeProcessor* type_processor() const {
     return static_cast<SharedModelTypeProcessor*>(change_processor());
   }
 
-  syncer::DataTypeErrorHandlerMock* error_handler() {
+  DataTypeErrorHandlerMock* error_handler() {
     DCHECK(error_handler_);
     return error_handler_;
   }
 
   int merge_call_count() const { return merge_call_count_; }
 
  private:
   void CheckPostConditions() override {
     FakeModelTypeService::CheckPostConditions();
     DCHECK(data_callback_.is_null());
-    DCHECK_EQ(syncer::SyncError::UNSET, expected_start_error_);
+    DCHECK_EQ(SyncError::UNSET, expected_start_error_);
   }
 
-  void OnReadyToConnect(syncer::SyncError error,
+  void OnReadyToConnect(SyncError error,
                         std::unique_ptr<ActivationContext> context) {
-    if (expected_start_error_ != syncer::SyncError::UNSET) {
+    if (expected_start_error_ != SyncError::UNSET) {
       EXPECT_TRUE(error.IsSet());
       EXPECT_EQ(expected_start_error_, error.error_type());
       EXPECT_EQ(nullptr, context);
-      expected_start_error_ = syncer::SyncError::UNSET;
+      expected_start_error_ = SyncError::UNSET;
       return;
     }
 
     std::unique_ptr<MockModelTypeWorker> worker(
         new MockModelTypeWorker(context->data_type_state, type_processor()));
     // Keep an unsafe pointer to the commit queue the processor will use.
     worker_ = worker.get();
     // The context contains a proxy to the processor, but this call is
     // side-stepping that completely and connecting directly to the real
     // processor, since these tests are single-threaded and don't need proxies.
     type_processor()->ConnectSync(std::move(worker));
   }
 
   // FakeModelTypeService overrides.
 
-  syncer::SyncError MergeSyncData(std::unique_ptr<MetadataChangeList> mcl,
-                                  EntityDataMap entity_data_map) override {
+  SyncError MergeSyncData(std::unique_ptr<MetadataChangeList> mcl,
+                          EntityDataMap entity_data_map) override {
     merge_call_count_++;
     return FakeModelTypeService::MergeSyncData(std::move(mcl), entity_data_map);
   }
 
   void CaptureDataCallback(DataCallback callback,
-                           syncer::SyncError error,
+                           SyncError error,
                            std::unique_ptr<DataBatch> data) {
     data_callback_ = base::Bind(callback, error, base::Passed(std::move(data)));
   }
 
   void GetData(StorageKeyList keys, DataCallback callback) override {
     FakeModelTypeService::GetData(
         keys, base::Bind(&SharedModelTypeProcessorTest::CaptureDataCallback,
                          base::Unretained(this), callback));
   }
 
   // This sets ThreadTaskRunnerHandle on the current thread, which the type
   // processor will pick up as the sync task runner.
   base::MessageLoop sync_loop_;
 
   // The current mock queue, which is owned by |type_processor()|.
   MockModelTypeWorker* worker_;
 
   // Stores the data callback between GetData() and OnPendingCommitDataLoaded().
   base::Closure data_callback_;
 
   // The processor's error handler.
-  syncer::DataTypeErrorHandlerMock* error_handler_;
+  DataTypeErrorHandlerMock* error_handler_;
 
   // The error to expect in OnReadyToConnect().
-  syncer::SyncError::ErrorType expected_start_error_ = syncer::SyncError::UNSET;
+  SyncError::ErrorType expected_start_error_ = SyncError::UNSET;
 
   // The number of times MergeSyncData has been called.
   int merge_call_count_ = 0;
 };
 
 // Test that an initial sync handles local and remote items properly.
 TEST_F(SharedModelTypeProcessorTest, InitialSync) {
   CreateChangeProcessor();
   OnMetadataLoaded();
   OnSyncStarting();
@@ skipping 39 matching lines @@
   EXPECT_EQ(2U, db().data_count());
   EXPECT_EQ(2U, db().metadata_count());
 }
 
 // Test that an error during the merge is propagated to the error handler.
 TEST_F(SharedModelTypeProcessorTest, InitialSyncError) {
   CreateChangeProcessor();
   OnMetadataLoaded();
   OnSyncStarting();
 
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   worker()->UpdateFromServer();
 }
 
 // Test that errors before it's called are passed to |start_callback| correctly.
 TEST_F(SharedModelTypeProcessorTest, StartErrors) {
   CreateChangeProcessor();
-  type_processor()->OnMetadataLoaded(
-      CreateSyncError(syncer::SyncError::DATATYPE_ERROR), nullptr);
-  ExpectStartError(syncer::SyncError::DATATYPE_ERROR);
+  type_processor()->OnMetadataLoaded(CreateSyncError(SyncError::DATATYPE_ERROR),
+                                     nullptr);
+  ExpectStartError(SyncError::DATATYPE_ERROR);
   OnSyncStarting();
 
   // Test OnSyncStarting happening first.
   ResetState();
   CreateChangeProcessor();
   OnSyncStarting();
-  ExpectStartError(syncer::SyncError::DATATYPE_ERROR);
-  type_processor()->OnMetadataLoaded(
-      CreateSyncError(syncer::SyncError::DATATYPE_ERROR), nullptr);
+  ExpectStartError(SyncError::DATATYPE_ERROR);
+  type_processor()->OnMetadataLoaded(CreateSyncError(SyncError::DATATYPE_ERROR),
+                                     nullptr);
 
   // Test an error loading pending data.
   ResetStateWriteItem(kKey1, kValue1);
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
   InitializeToMetadataLoaded();
   OnPendingCommitDataLoaded();
-  ExpectStartError(syncer::SyncError::DATATYPE_ERROR);
+  ExpectStartError(SyncError::DATATYPE_ERROR);
   OnSyncStarting();
 }
 
 // This test covers race conditions during loading pending data. All cases
 // start with no processor and one acked (committed to the server) item with a
 // pending commit. There are three different events that can occur in any order
 // once metadata is loaded:
 //
 // - Pending commit data is loaded.
 // - Sync gets connected.
@@ skipping 244 matching lines @@
   EXPECT_EQ(1, acked_metadata.sequence_number());
   EXPECT_EQ(1, acked_metadata.acked_sequence_number());
   EXPECT_EQ(1, acked_metadata.server_version());
 }
 
 // Test that an error applying metadata changes from a commit response is
 // propagated to the error handler.
 TEST_F(SharedModelTypeProcessorTest, ErrorApplyingAck) {
   InitializeToReadyState();
   WriteItem(kKey1, kValue1);
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   worker()->AckOnePendingCommit();
 }
 
 // The purpose of this test case is to test setting |client_tag_hash| and |id|
 // on the EntityData object as we pass it into the Put method of the processor.
 TEST_F(SharedModelTypeProcessorTest, LocalUpdateItemWithOverrides) {
   const std::string kId1 = "cid1";
   const std::string kId2 = "cid2";
 
   InitializeToReadyState();
@@ skipping 143 matching lines @@
   EXPECT_EQ(1, metadata.server_version());
   EXPECT_TRUE(metadata.has_creation_time());
   EXPECT_TRUE(metadata.has_modification_time());
   EXPECT_TRUE(metadata.has_specifics_hash());
 }
 
 // Test that an error applying changes from a server update is
 // propagated to the error handler.
 TEST_F(SharedModelTypeProcessorTest, ErrorApplyingUpdate) {
   InitializeToReadyState();
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   worker()->UpdateFromServer(kHash1, GenerateSpecifics(kKey1, kValue1));
 }
 
 // Thoroughly tests the data generated by a server item creation.
 TEST_F(SharedModelTypeProcessorTest, ServerUpdateItem) {
   InitializeToReadyState();
 
   // Local add writes data and metadata; ack writes metadata again.
   WriteItemAndAck(kKey1, kValue1);
   EXPECT_EQ(1U, db().data_change_count());
@@ skipping 319 matching lines @@
   OnPendingCommitDataLoaded();
   ASSERT_EQ(3U, worker()->GetNumPendingCommits());
   worker()->ExpectNthPendingCommit(2, kHash1, specifics1);
 }
 
 // Test that an error loading pending commit data for re-encryption is
 // propagated to the error handler.
 TEST_F(SharedModelTypeProcessorTest, ReEncryptErrorLoadingData) {
   InitializeToReadyState();
   WriteItemAndAck(kKey1, kValue1);
-  SetServiceError(syncer::SyncError::DATATYPE_ERROR);
+  SetServiceError(SyncError::DATATYPE_ERROR);
   worker()->UpdateWithEncryptionKey("k1");
-  error_handler()->ExpectError(syncer::SyncError::DATATYPE_ERROR);
+  error_handler()->ExpectError(SyncError::DATATYPE_ERROR);
   OnPendingCommitDataLoaded();
 }
 
 // Test receipt of updates with new and old keys.
 TEST_F(SharedModelTypeProcessorTest, ReEncryptUpdatesWithNewKey) {
   InitializeToReadyState();
 
   // Receive an unencrypted update.
   worker()->UpdateFromServer(kHash1, GenerateSpecifics(kKey1, kValue1));
   ASSERT_EQ(0U, worker()->GetNumPendingCommits());
@@ skipping 139 matching lines @@
   worker()->ExpectNthPendingCommit(0, kHash1, specifics2);
 
   UpdateResponseDataList update;
   update.push_back(worker()->GenerateUpdateData(kHash1, specifics1, 1, "k1"));
   worker()->UpdateWithEncryptionKey("k1", update);
 
   EXPECT_EQ(2U, worker()->GetNumPendingCommits());
   worker()->ExpectNthPendingCommit(1, kHash1, specifics2);
 }
 
-}  // namespace syncer_v2
+}  // namespace syncer