[Sync] Move //sync to //components/sync.

components/sync/test/fake_server/fake_server_verifier.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 "sync/test/fake_server/fake_server_verifier.h"
+#include "components/sync/test/fake_server/fake_server_verifier.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
-#include "sync/internal_api/public/base/model_type.h"
-#include "sync/test/fake_server/fake_server.h"
-#include "sync/test/fake_server/sessions_hierarchy.h"
+#include "components/sync/base/model_type.h"
+#include "components/sync/test/fake_server/fake_server.h"
+#include "components/sync/test/fake_server/sessions_hierarchy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::JSONWriter;
 using std::string;
 using testing::AssertionFailure;
 using testing::AssertionResult;
 using testing::AssertionSuccess;
 
 namespace fake_server {
 
@@ skipping 33 matching lines @@
   if (!JSONWriter::WriteWithOptions(entities, JSONWriter::OPTIONS_PRETTY_PRINT,
                                     &entities_str)) {
     entities_str = "Could not convert FakeServer contents to string.";
   }
   return "FakeServer contents:\n" + entities_str;
 }
 
 }  // namespace
 
 FakeServerVerifier::FakeServerVerifier(FakeServer* fake_server)
-    : fake_server_(fake_server) { }
+    : fake_server_(fake_server) {}
 
 FakeServerVerifier::~FakeServerVerifier() {}
 
 AssertionResult FakeServerVerifier::VerifyEntityCountByType(
     size_t expected_count,
     syncer::ModelType model_type) const {
   std::unique_ptr<base::DictionaryValue> entities =
       fake_server_->GetEntitiesAsDictionaryValue();
   if (!entities.get()) {
     return DictionaryCreationAssertionFailure();
   }
 
   string model_type_string = ModelTypeToString(model_type);
   base::ListValue* entity_list = NULL;
   if (!entities->GetList(model_type_string, &entity_list)) {
     return UnknownTypeAssertionFailure(model_type_string);
-  } else if  (expected_count != entity_list->GetSize()) {
+  } else if (expected_count != entity_list->GetSize()) {
     return VerificationCountAssertionFailure(entity_list->GetSize(),
                                              expected_count)
-        << "\n\n"
-        << ConvertFakeServerContentsToString(*entities);
+           << "\n\n"
+           << ConvertFakeServerContentsToString(*entities);
   }
 
   return AssertionSuccess();
 }
 
 AssertionResult FakeServerVerifier::VerifyEntityCountByTypeAndName(
     size_t expected_count,
     syncer::ModelType model_type,
     const string& name) const {
   std::unique_ptr<base::DictionaryValue> entities =
@@ skipping 10 matching lines @@
     for (const auto& entity : *entity_list) {
       if (name_value.Equals(entity.get()))
         actual_count++;
     }
   }
 
   if (!entity_list) {
     return UnknownTypeAssertionFailure(model_type_string);
   } else if (actual_count != expected_count) {
     return VerificationCountAssertionFailure(actual_count, expected_count)
-        << "; Name: "
-        << name
-        << "\n\n"
-        << ConvertFakeServerContentsToString(*entities);
+           << "; Name: " << name << "\n\n"
+           << ConvertFakeServerContentsToString(*entities);
   }
 
   return AssertionSuccess();
 }
 
 AssertionResult FakeServerVerifier::VerifySessions(
     const SessionsHierarchy& expected_sessions) {
   std::vector<sync_pb::SyncEntity> sessions =
       fake_server_->GetSyncEntitiesByModelType(syncer::SESSIONS);
   // Look for the sessions entity containing a SessionHeader and cache all tab
@@ skipping 42 matching lines @@
         return AssertionFailure() << "Malformed data: Tab entity not found.";
       }
       tab_urls.insert(tab_ids_to_urls[tab_id]);
     }
     actual_sessions.AddWindow(tab_urls);
   }
   return VerifySessionsHierarchyEquality(expected_sessions, actual_sessions);
 }
 
 }  // namespace fake_server