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

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"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
+#include "components/sync/base/cancelation_signal.h"
+#include "components/sync/core/http_bridge.h"
+#include "components/sync/core/http_post_provider_factory.h"
 #include "net/http/http_response_headers.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_test_util.h"
-#include "sync/internal_api/public/base/cancelation_signal.h"
-#include "sync/internal_api/public/http_bridge.h"
-#include "sync/internal_api/public/http_post_provider_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
 // TODO(timsteele): Should use PathService here. See Chromium Issue 3113.
 const base::FilePath::CharType kDocRoot[] =
     FILE_PATH_LITERAL("chrome/test/data");
 
@@ skipping 35 matching lines @@
       fake_default_request_context_getter_ =
           new net::TestURLRequestContextGetter(io_thread_.task_runner());
       fake_default_request_context_getter_->AddRef();
     }
     HttpBridge* bridge =
         new HttpBridge(kUserAgent, fake_default_request_context_getter_,
                        NetworkTimeUpdateCallback(), BindToTrackerCallback());
     return bridge;
   }
 
-  static void Abort(HttpBridge* bridge) {
-    bridge->Abort();
-  }
+  static void Abort(HttpBridge* bridge) { bridge->Abort(); }
 
   // Used by AbortAndReleaseBeforeFetchCompletes to test an interesting race
   // condition.
   void RunSyncThreadBridgeUseTest(base::WaitableEvent* signal_when_created,
                                   base::WaitableEvent* signal_when_released);
 
   static void TestSameHttpNetworkSession(base::MessageLoop* main_message_loop,
                                          MAYBE_SyncHttpBridgeTest* test) {
     scoped_refptr<HttpBridge> http_bridge(test->BuildBridge());
     EXPECT_TRUE(test->GetTestRequestContextGetter());
-    net::HttpNetworkSession* test_session =
-        test->GetTestRequestContextGetter()->GetURLRequestContext()->
-        http_transaction_factory()->GetSession();
-    EXPECT_EQ(test_session,
-              http_bridge->GetRequestContextGetterForTest()->
-                  GetURLRequestContext()->
-                  http_transaction_factory()->GetSession());
+    net::HttpNetworkSession* test_session = test->GetTestRequestContextGetter()
+                                                ->GetURLRequestContext()
+                                                ->http_transaction_factory()
+                                                ->GetSession();
+    EXPECT_EQ(test_session, http_bridge->GetRequestContextGetterForTest()
+                                ->GetURLRequestContext()
+                                ->http_transaction_factory()
+                                ->GetSession());
     main_message_loop->task_runner()->PostTask(
         FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
   }
 
   base::MessageLoop* GetIOThreadLoop() { return io_thread_.message_loop(); }
 
   // Note this is lazy created, so don't call this before your bridge.
   net::TestURLRequestContextGetter* GetTestRequestContextGetter() {
     return fake_default_request_context_getter_;
   }
@@ skipping 194 matching lines @@
   int response_code = 0;
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   EXPECT_TRUE(success);
   EXPECT_EQ(200, response_code);
   EXPECT_EQ(0, os_error);
 
   std::string response(http_bridge->GetResponseContent(),
                        http_bridge->GetResponseContentLength());
   EXPECT_EQ(std::string::npos, response.find("Cookie:"));
   EXPECT_NE(std::string::npos,
-            response.find(base::StringPrintf("%s: %s",
-                          net::HttpRequestHeaders::kUserAgent, kUserAgent)));
+            response.find(base::StringPrintf(
+                "%s: %s", net::HttpRequestHeaders::kUserAgent, kUserAgent)));
   EXPECT_NE(std::string::npos, response.find(test_payload.c_str()));
 }
 
 TEST_F(MAYBE_SyncHttpBridgeTest, TestExtraRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   GURL echo_header = test_server_.GetURL("/echoall");
 
@@ skipping 111 matching lines @@
 
   // Schedule the fetch completion callback (but don't run it yet). Don't take
   // a reference to the bridge to mimic URLFetcher's handling of the delegate.
   net::URLFetcherDelegate* delegate =
       static_cast<net::URLFetcherDelegate*>(bridge_for_race_test());
   std::string response_content = "success!";
   net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
   fetcher.set_response_code(200);
   fetcher.SetResponseString(response_content);
   ASSERT_TRUE(io_thread()->task_runner()->PostTask(
-      FROM_HERE,
-      base::Bind(&net::URLFetcherDelegate::OnURLFetchComplete,
-          base::Unretained(delegate), &fetcher)));
+      FROM_HERE, base::Bind(&net::URLFetcherDelegate::OnURLFetchComplete,
+                            base::Unretained(delegate), &fetcher)));
 
   // Abort the fetch. This should be smart enough to handle the case where
   // the bridge is destroyed before the callback scheduled above completes.
   bridge_for_race_test()->Abort();
 
   // Wait until the sync thread releases its ref on the bridge.
   signal_when_released.Wait();
   ASSERT_FALSE(bridge_for_race_test());
 
   // Unleash the hounds. The fetch completion callback should fire first, and
@@ skipping 117 matching lines @@
 
   // 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