Remove Android filter file for sync_unit_tests.

sync/internal_api/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 "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/mock_entropy_provider.h"
 #include "base/threading/thread.h"
 #include "net/http/http_response_headers.h"
@@ skipping 88 matching lines @@
     output->swap(uncompressed_output);
     return true;
   }
   return false;
 }
 
 }  // namespace
 
 const char kUserAgent[] = "user-agent";
 
-class SyncHttpBridgeTest : public testing::Test {
+#if defined(OS_ANDROID)
+#define MAYBE_SyncHttpBridgeTest DISABLED_SyncHttpBridgeTest
+#else
+#define MAYBE_SyncHttpBridgeTest SyncHttpBridgeTest
+#endif  // defined(OS_ANDROID)
+class MAYBE_SyncHttpBridgeTest : public testing::Test {
  public:
-  SyncHttpBridgeTest()
+  MAYBE_SyncHttpBridgeTest()
       : test_server_(net::SpawnedTestServer::TYPE_HTTP,
                      net::SpawnedTestServer::kLocalhost,
                      base::FilePath(kDocRoot)),
         fake_default_request_context_getter_(NULL),
         bridge_for_race_test_(NULL),
         io_thread_("IO thread") {
   }
 
   void SetUp() override {
     base::Thread::Options options;
@@ skipping 26 matching lines @@
   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,
-                                         SyncHttpBridgeTest* test) {
+                                         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());
     main_message_loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
@@ skipping 26 matching lines @@
 
 // An HttpBridge that doesn't actually make network requests and just calls
 // back with dummy response info.
 // TODO(tim): Instead of inheriting here we should inject a component
 // responsible for the MakeAsynchronousPost bit.
 class ShuntedHttpBridge : public HttpBridge {
  public:
   // If |never_finishes| is true, the simulated request never actually
   // returns.
   ShuntedHttpBridge(net::URLRequestContextGetter* baseline_context_getter,
-                    SyncHttpBridgeTest* test, bool never_finishes)
+                    MAYBE_SyncHttpBridgeTest* test, bool never_finishes)
       : HttpBridge(kUserAgent,
                    baseline_context_getter,
                    NetworkTimeUpdateCallback()),
         test_(test), never_finishes_(never_finishes) { }
  protected:
   void MakeAsynchronousPost() override {
     ASSERT_TRUE(base::MessageLoop::current() == test_->GetIOThreadLoop());
     if (never_finishes_)
       return;
 
@@ skipping 13 matching lines @@
     std::string response_content = "success!";
     net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
     scoped_refptr<net::HttpResponseHeaders> response_headers(
         new net::HttpResponseHeaders(""));
     fetcher.set_response_code(200);
     fetcher.set_cookies(cookies);
     fetcher.SetResponseString(response_content);
     fetcher.set_response_headers(response_headers);
     OnURLFetchComplete(&fetcher);
   }
-  SyncHttpBridgeTest* test_;
+  MAYBE_SyncHttpBridgeTest* test_;
   bool never_finishes_;
 };
 
-void SyncHttpBridgeTest::RunSyncThreadBridgeUseTest(
+void MAYBE_SyncHttpBridgeTest::RunSyncThreadBridgeUseTest(
     base::WaitableEvent* signal_when_created,
     base::WaitableEvent* signal_when_released) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
       new net::TestURLRequestContextGetter(io_thread_.task_runner()));
   {
     scoped_refptr<ShuntedHttpBridge> bridge(
         new ShuntedHttpBridge(ctx_getter.get(), this, true));
     bridge->SetURL("http://www.google.com", 9999);
     bridge->SetPostPayload("text/plain", 2, " ");
     bridge_for_race_test_ = bridge.get();
     signal_when_created->Signal();
 
     int os_error = 0;
     int response_code = 0;
     bridge->MakeSynchronousPost(&os_error, &response_code);
     bridge_for_race_test_ = NULL;
   }
   signal_when_released->Signal();
 }
 
-TEST_F(SyncHttpBridgeTest, TestUsesSameHttpNetworkSession) {
+TEST_F(MAYBE_SyncHttpBridgeTest, TestUsesSameHttpNetworkSession) {
   // Run this test on the IO thread because we can only call
   // URLRequestContextGetter::GetURLRequestContext on the IO thread.
-  io_thread()->message_loop()
-      ->PostTask(FROM_HERE,
-                 base::Bind(&SyncHttpBridgeTest::TestSameHttpNetworkSession,
-                            base::MessageLoop::current(),
-                            this));
+  io_thread()->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&MAYBE_SyncHttpBridgeTest::TestSameHttpNetworkSession,
+                 base::MessageLoop::current(), this));
   base::MessageLoop::current()->Run();
 }
 
 // Test the HttpBridge without actually making any network requests.
-TEST_F(SyncHttpBridgeTest, TestMakeSynchronousPostShunted) {
+TEST_F(MAYBE_SyncHttpBridgeTest, TestMakeSynchronousPostShunted) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   scoped_refptr<HttpBridge> http_bridge(
       new ShuntedHttpBridge(ctx_getter.get(), this, false));
   http_bridge->SetURL("http://www.google.com", 9999);
   http_bridge->SetPostPayload("text/plain", 2, " ");
 
   int os_error = 0;
   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);
 
   EXPECT_EQ(8, http_bridge->GetResponseContentLength());
   EXPECT_EQ(std::string("success!"),
             std::string(http_bridge->GetResponseContent()));
 }
 
 // Full round-trip test of the HttpBridge, using default UA string and
 // no request cookies.
-TEST_F(SyncHttpBridgeTest, TestMakeSynchronousPostLiveWithPayload) {
+TEST_F(MAYBE_SyncHttpBridgeTest, TestMakeSynchronousPostLiveWithPayload) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   std::string payload = "this should be echoed back";
   GURL echo = test_server_.GetURL("echo");
   http_bridge->SetURL(echo.spec().c_str(), echo.IntPort());
   http_bridge->SetPostPayload("application/x-www-form-urlencoded",
                               payload.length() + 1, payload.c_str());
   int os_error = 0;
   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);
 
   EXPECT_EQ(payload.length() + 1,
             static_cast<size_t>(http_bridge->GetResponseContentLength()));
   EXPECT_EQ(payload, std::string(http_bridge->GetResponseContent()));
 }
 
 // Full round-trip test of the HttpBridge with compressed data, check if the
 // data is correctly compressed.
-TEST_F(SyncHttpBridgeTest, CompressedRequestPayloadCheck) {
+TEST_F(MAYBE_SyncHttpBridgeTest, CompressedRequestPayloadCheck) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   std::string payload = "this should be echoed back";
   GURL echo = test_server_.GetURL("echo");
   http_bridge->SetURL(echo.spec().c_str(), echo.IntPort());
   http_bridge->SetPostPayload("application/x-www-form-urlencoded",
                               payload.length(), payload.c_str());
   int os_error = 0;
@@ skipping 11 matching lines @@
   std::string compressed_payload(http_bridge->GetResponseContent(),
                                  http_bridge->GetResponseContentLength());
   std::string uncompressed_payload;
   GzipUncompress(compressed_payload, &uncompressed_payload);
   EXPECT_EQ(payload, uncompressed_payload);
 }
 
 // Full round-trip test of the HttpBridge with compression, check if header
 // fields("Content-Encoding" ,"Accept-Encoding" and user agent) are set
 // correctly.
-TEST_F(SyncHttpBridgeTest, CompressedRequestHeaderCheck) {
+TEST_F(MAYBE_SyncHttpBridgeTest, CompressedRequestHeaderCheck) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   GURL echo_header = test_server_.GetURL("echoall");
   http_bridge->SetURL(echo_header.spec().c_str(), echo_header.IntPort());
 
   std::string test_payload = "###TEST PAYLOAD###";
   http_bridge->SetPostPayload("text/html", test_payload.length() + 1,
                               test_payload.c_str());
@@ skipping 14 matching lines @@
   EXPECT_NE(std::string::npos,
             response.find(base::StringPrintf(
                 "%s: %s", net::HttpRequestHeaders::kAcceptEncoding,
                 "gzip, deflate")));
   EXPECT_NE(std::string::npos,
             response.find(base::StringPrintf(
                 "%s: %s", net::HttpRequestHeaders::kUserAgent, kUserAgent)));
 }
 
 // Full round-trip test of the HttpBridge.
-TEST_F(SyncHttpBridgeTest, TestMakeSynchronousPostLiveComprehensive) {
+TEST_F(MAYBE_SyncHttpBridgeTest, TestMakeSynchronousPostLiveComprehensive) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   GURL echo_header = test_server_.GetURL("echoall");
   http_bridge->SetURL(echo_header.spec().c_str(), echo_header.IntPort());
 
   std::string test_payload = "###TEST PAYLOAD###";
   http_bridge->SetPostPayload("text/html", test_payload.length() + 1,
                               test_payload.c_str());
@@ skipping 11 matching lines @@
   EXPECT_NE(std::string::npos,
             response.find(base::StringPrintf(
                 "%s: %s", net::HttpRequestHeaders::kAcceptEncoding,
                 "deflate")));
   EXPECT_NE(std::string::npos,
             response.find(base::StringPrintf("%s: %s",
                           net::HttpRequestHeaders::kUserAgent, kUserAgent)));
   EXPECT_NE(std::string::npos, response.find(test_payload.c_str()));
 }
 
-TEST_F(SyncHttpBridgeTest, TestExtraRequestHeaders) {
+TEST_F(MAYBE_SyncHttpBridgeTest, TestExtraRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   GURL echo_header = test_server_.GetURL("echoall");
 
   http_bridge->SetURL(echo_header.spec().c_str(), echo_header.IntPort());
   http_bridge->SetExtraRequestHeaders("test:fnord");
 
   std::string test_payload = "###TEST PAYLOAD###";
   http_bridge->SetPostPayload("text/html", test_payload.length() + 1,
                               test_payload.c_str());
 
   int os_error = 0;
   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_NE(std::string::npos, response.find("fnord"));
   EXPECT_NE(std::string::npos, response.find(test_payload.c_str()));
 }
 
-TEST_F(SyncHttpBridgeTest, TestResponseHeader) {
+TEST_F(MAYBE_SyncHttpBridgeTest, TestResponseHeader) {
   ASSERT_TRUE(test_server_.Start());
 
   scoped_refptr<HttpBridge> http_bridge(BuildBridge());
 
   GURL echo_header = test_server_.GetURL("echoall");
   http_bridge->SetURL(echo_header.spec().c_str(), echo_header.IntPort());
 
   std::string test_payload = "###TEST PAYLOAD###";
   http_bridge->SetPostPayload("text/html", test_payload.length() + 1,
                               test_payload.c_str());
 
   int os_error = 0;
   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);
 
   EXPECT_EQ(http_bridge->GetResponseHeaderValue("Content-type"), "text/html");
   EXPECT_TRUE(http_bridge->GetResponseHeaderValue("invalid-header").empty());
 }
 
-TEST_F(SyncHttpBridgeTest, Abort) {
+TEST_F(MAYBE_SyncHttpBridgeTest, Abort) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   scoped_refptr<ShuntedHttpBridge> http_bridge(
       new ShuntedHttpBridge(ctx_getter.get(), this, true));
   http_bridge->SetURL("http://www.google.com", 9999);
   http_bridge->SetPostPayload("text/plain", 2, " ");
 
   int os_error = 0;
   int response_code = 0;
 
   io_thread()->task_runner()->PostTask(
       FROM_HERE,
-      base::Bind(&SyncHttpBridgeTest::Abort, http_bridge));
+      base::Bind(&MAYBE_SyncHttpBridgeTest::Abort, http_bridge));
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   EXPECT_FALSE(success);
   EXPECT_EQ(net::ERR_ABORTED, os_error);
 }
 
-TEST_F(SyncHttpBridgeTest, AbortLate) {
+TEST_F(MAYBE_SyncHttpBridgeTest, AbortLate) {
   scoped_refptr<net::URLRequestContextGetter> ctx_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
   scoped_refptr<ShuntedHttpBridge> http_bridge(
       new ShuntedHttpBridge(ctx_getter.get(), this, false));
   http_bridge->SetURL("http://www.google.com", 9999);
   http_bridge->SetPostPayload("text/plain", 2, " ");
 
   int os_error = 0;
   int response_code = 0;
 
   bool success = http_bridge->MakeSynchronousPost(&os_error, &response_code);
   ASSERT_TRUE(success);
   http_bridge->Abort();
   // Ensures no double-free of URLFetcher, etc.
 }
 
 // Tests an interesting case where code using the HttpBridge aborts the fetch
 // and releases ownership before a pending fetch completed callback is issued by
 // the underlying URLFetcher (and before that URLFetcher is destroyed, which
 // would cancel the callback).
-TEST_F(SyncHttpBridgeTest, AbortAndReleaseBeforeFetchComplete) {
+TEST_F(MAYBE_SyncHttpBridgeTest, AbortAndReleaseBeforeFetchComplete) {
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
   // First, block the sync thread on the post.
   base::WaitableEvent signal_when_created(false, false);
   base::WaitableEvent signal_when_released(false, false);
   sync_thread.message_loop()->PostTask(FROM_HERE,
-      base::Bind(&SyncHttpBridgeTest::RunSyncThreadBridgeUseTest,
+      base::Bind(&MAYBE_SyncHttpBridgeTest::RunSyncThreadBridgeUseTest,
                  base::Unretained(this),
                  &signal_when_created,
                  &signal_when_released));
 
   // Stop IO so we can control order of operations.
   base::WaitableEvent io_waiter(false, false);
   ASSERT_TRUE(io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&io_waiter))));
 
@@ skipping 57 matching lines @@
 }
 
 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(SyncHttpBridgeTest, RequestContextGetterReleaseOrder) {
+TEST_F(MAYBE_SyncHttpBridgeTest, RequestContextGetterReleaseOrder) {
   base::Thread sync_thread("SyncThread");
   sync_thread.Start();
 
   syncer::HttpPostProviderFactory* factory = NULL;
   syncer::HttpPostProviderInterface* bridge = NULL;
 
   scoped_refptr<net::URLRequestContextGetter> baseline_context_getter(
       new net::TestURLRequestContextGetter(io_thread()->task_runner()));
 
   base::WaitableEvent signal_when_created(false, false);
@@ skipping 32 matching lines @@
   wait_done.Signal();
   io_thread()->Stop();
 
   // Unblock and stop sync thread.
   wait_for_shutdown.Signal();
   sync_thread.Stop();
 }
 
 // Attempt to release the URLRequestContextGetter before the HttpBridgeFactory
 // is initialized.
-TEST_F(SyncHttpBridgeTest, EarlyAbortFactory) {
+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.
   scoped_ptr<syncer::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");
 
   // 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