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

components/sync/core/http_bridge_unittest.cc

 // Copyright 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bit_cast.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 447 matching lines @@
   io_waiter.Signal();
 
   // Done.
   sync_thread.Stop();
   io_thread()->Stop();
 }
 
 void HttpBridgeRunOnSyncThread(
     net::URLRequestContextGetter* baseline_context_getter,
     CancelationSignal* factory_cancelation_signal,
-    syncer::HttpPostProviderFactory** bridge_factory_out,
-    syncer::HttpPostProviderInterface** bridge_out,
+    HttpPostProviderFactory** bridge_factory_out,
+    HttpPostProviderInterface** bridge_out,
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* wait_for_shutdown) {
-  std::unique_ptr<syncer::HttpBridgeFactory> bridge_factory(
-      new syncer::HttpBridgeFactory(baseline_context_getter,
-                                    NetworkTimeUpdateCallback(),
-                                    factory_cancelation_signal));
+  std::unique_ptr<HttpBridgeFactory> bridge_factory(new HttpBridgeFactory(
+      baseline_context_getter, NetworkTimeUpdateCallback(),
+      factory_cancelation_signal));
   bridge_factory->Init("test", BindToTrackerCallback());
   *bridge_factory_out = bridge_factory.get();
 
   HttpPostProviderInterface* bridge = bridge_factory->Create();
   *bridge_out = bridge;
 
   signal_when_created->Signal();
   wait_for_shutdown->Wait();
 
   bridge_factory->Destroy(bridge);
 }
 
 void WaitOnIOThread(base::WaitableEvent* signal_wait_start,
                     base::WaitableEvent* wait_done) {
   signal_wait_start->Signal();
   wait_done->Wait();
 }
 
 // Tests RequestContextGetter is properly released on IO thread even when
 // IO thread stops before sync thread.
 TEST_F(MAYBE_SyncHttpBridgeTest, RequestContextGetterReleaseOrder) {
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
-  syncer::HttpPostProviderFactory* factory = NULL;
-  syncer::HttpPostProviderInterface* bridge = NULL;
+  HttpPostProviderFactory* factory = NULL;
+  HttpPostProviderInterface* bridge = NULL;
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
 
   base::WaitableEvent signal_when_created(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::WaitableEvent wait_for_shutdown(
       base::WaitableEvent::ResetPolicy::AUTOMATIC,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
@@ skipping 44 matching lines @@
 TEST_F(MAYBE_SyncHttpBridgeTest, EarlyAbortFactory) {
   // In a real scenario, the following would happen on many threads.  For
   // simplicity, this test uses only one thread.
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   CancelationSignal release_request_context_signal;
 
   // UI Thread: Initialize the HttpBridgeFactory.  The next step would be to
   // post a task to SBH::Core to have it initialized.
-  std::unique_ptr<syncer::HttpBridgeFactory> factory(new HttpBridgeFactory(
+  std::unique_ptr<HttpBridgeFactory> factory(new HttpBridgeFactory(
       baseline_context_getter.get(), NetworkTimeUpdateCallback(),
       &release_request_context_signal));
 
   // UI Thread: A very early shutdown request arrives and executes on the UI
   // thread before the posted sync thread task is run.
   release_request_context_signal.Signal();
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent", BindToTrackerCallback());
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 }
 
 }  // namespace syncer