Fix and re-enable URLRequestFTP tests (Except on Android).

net/url_request/url_request_unittest.cc

 // Copyright (c) 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 19 matching lines @@
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/cert/ev_root_ca_metadata.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/cert/test_root_certs.h"
 #include "net/cert_net/nss_ocsp.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store_test_helpers.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/dns/mock_host_resolver.h"
-#include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/log/net_log.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
@@ skipping 16 matching lines @@
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 #if !defined(DISABLE_FILE_SUPPORT)
 #include "net/base/filename_util.h"
 #include "net/url_request/file_protocol_handler.h"
 #include "net/url_request/url_request_file_dir_job.h"
 #endif
 
-#if !defined(DISABLE_FTP_SUPPORT)
+#if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
+#include "net/ftp/ftp_network_layer.h"
 #include "net/url_request/ftp_protocol_handler.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #endif
 
 using base::ASCIIToUTF16;
 using base::Time;
 using std::string;
 
 namespace net {
 
 namespace {
 
 const base::string16 kChrome(ASCIIToUTF16("chrome"));
 const base::string16 kSecret(ASCIIToUTF16("secret"));
 const base::string16 kUser(ASCIIToUTF16("user"));
 
+const base::FilePath::CharType kTestFilePath[] =
+    FILE_PATH_LITERAL("net/data/url_request_unittest");
+
+#if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
+// Test file used in most FTP tests.
+const char kFtpTestFile[] = "BullRunSpeech.txt";
+#endif
+
 // Tests load timing information in the case a fresh connection was used, with
 // no proxy.
 void TestLoadTimingNotReused(const LoadTimingInfo& load_timing_info,
                              int connect_timing_flags) {
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
 
@@ skipping 89 matching lines @@
 
   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
   EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start);
   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 
   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
 }
 
-#if !defined(DISABLE_FTP_SUPPORT)
+#if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
 // Tests load timing in the case that there is no HTTP response.  This can be
 // used to test in the case of errors or non-HTTP requests.
 void TestLoadTimingNoHttpResponse(
     const LoadTimingInfo& load_timing_info) {
   EXPECT_FALSE(load_timing_info.socket_reused);
   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 
   // Only the request times should be non-null.
   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
   EXPECT_FALSE(load_timing_info.request_start.is_null());
@@ skipping 730 matching lines @@
 }
 
 TEST_F(URLRequestTest, FileDirOutputSanity) {
   // Verify the general sanity of the the output of the file:
   // directory lister by checking for the output of a known existing
   // file.
   const char sentinel_name[] = "filedir-sentinel";
 
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
-  path = path.Append(FILE_PATH_LITERAL("net"));
-  path = path.Append(FILE_PATH_LITERAL("data"));
-  path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+  path = path.Append(kTestFilePath);
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
       FilePathToFileURL(path), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   // Generate entry for the sentinel file.
   base::FilePath sentinel_path = path.AppendASCII(sentinel_name);
   base::File::Info info;
@@ skipping 14 matching lines @@
   ASSERT_NE(data.find(sentinel_output), std::string::npos);
 }
 
 TEST_F(URLRequestTest, FileDirRedirectNoCrash) {
   // There is an implicit redirect when loading a file path that matches a
   // directory and does not end with a slash.  Ensure that following such
   // redirects does not crash.  See http://crbug.com/18686.
 
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
-  path = path.Append(FILE_PATH_LITERAL("net"));
-  path = path.Append(FILE_PATH_LITERAL("data"));
-  path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+  path = path.Append(kTestFilePath);
 
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
       FilePathToFileURL(path), DEFAULT_PRIORITY, &d));
   req->Start();
   base::RunLoop().Run();
 
   ASSERT_EQ(1, d.received_redirect_count());
   ASSERT_LT(0, d.bytes_received());
   ASSERT_FALSE(d.request_failed());
@@ skipping 42 matching lines @@
 
   req->Start();
   base::RunLoop().Run();
   EXPECT_TRUE(d.request_failed());
 }
 
 #if defined(OS_WIN)
 TEST_F(URLRequestTest, ResolveShortcutTest) {
   base::FilePath app_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("net");
-  app_path = app_path.AppendASCII("data");
-  app_path = app_path.AppendASCII("url_request_unittest");
+  app_path = app_path.Append(kTestFilePath);
   app_path = app_path.AppendASCII("with-headers.html");
 
   std::wstring lnk_path = app_path.value() + L".lnk";
 
   base::win::ScopedCOMInitializer com_initializer;
 
   // Temporarily create a shortcut for test
   {
     base::win::ScopedComPtr<IShellLink> shell;
     ASSERT_TRUE(SUCCEEDED(shell.CreateInstance(CLSID_ShellLink, NULL,
@@ skipping 1720 matching lines @@
 
     req->Start();
     base::RunLoop().Run();
 
     EXPECT_EQ("None", d.data_received());
   }
 }
 
 class URLRequestTestHTTP : public URLRequestTest {
  public:
-  URLRequestTestHTTP()
-      : test_server_(base::FilePath(FILE_PATH_LITERAL(
-                                  "net/data/url_request_unittest"))) {
-  }
+  URLRequestTestHTTP() : test_server_(base::FilePath(kTestFilePath)) {}
 
  protected:
   // Requests |redirect_url|, which must return a HTTP 3xx redirect.
   // |request_method| is the method to use for the initial request.
   // |redirect_method| is the method that is expected to be used for the second
   // request, after redirection.
   // If |include_data| is true, data is uploaded with the request.  The
   // response body is expected to match it exactly, if and only if
   // |request_method| == |redirect_method|.
   void HTTPRedirectMethodTest(const GURL& redirect_url,
@@ skipping 2318 matching lines @@
     r->set_method("POST");
 
     base::FilePath dir;
     PathService::Get(base::DIR_EXE, &dir);
     base::SetCurrentDirectory(dir);
 
     ScopedVector<UploadElementReader> element_readers;
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
-    path = path.Append(FILE_PATH_LITERAL("net"));
-    path = path.Append(FILE_PATH_LITERAL("data"));
-    path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+    path = path.Append(kTestFilePath);
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
     element_readers.push_back(
         new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                     path,
                                     0,
                                     kuint64max,
                                     base::Time()));
     r->set_upload(make_scoped_ptr<UploadDataStream>(
         new ElementsUploadDataStream(element_readers.Pass(), 0)));
 
@@ skipping 137 matching lines @@
   // The response has two "X-Multiple-Entries" headers.
   // This verfies our output has them concatenated together.
   header.clear();
   EXPECT_TRUE(headers->GetNormalizedHeader("x-multiple-entries", &header));
   EXPECT_EQ("a, b", header);
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTS) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
+                                      ssl_options,
+                                      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
   std::string test_server_hostname = https_test_server.GetURL("").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-headers.html"), DEFAULT_PRIORITY,
       &d));
   request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(test_server_hostname,
                                                     &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.sts.upgrade_mode);
   EXPECT_TRUE(domain_state.sts.include_subdomains);
   EXPECT_FALSE(domain_state.pkp.include_subdomains);
 #if defined(OS_ANDROID)
   // Android's CertVerifyProc does not (yet) handle pins.
 #else
   EXPECT_FALSE(domain_state.HasPublicKeyPins());
 #endif
 }
 
 TEST_F(URLRequestTestHTTP, STSNotProcessedOnIP) {
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::SSLOptions(),
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
+                                      SpawnedTestServer::SSLOptions(),
+                                      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
   // Make sure this test fails if the test server is changed to not
   // listen on an IP by default.
   ASSERT_TRUE(https_test_server.GetURL("").HostIsIPAddress());
   std::string test_server_hostname = https_test_server.GetURL("").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-headers.html"), DEFAULT_PRIORITY,
       &d));
@@ skipping 14 matching lines @@
 #define MAYBE_ProcessPKP DISABLED_ProcessPKP
 #else
 #define MAYBE_ProcessPKP ProcessPKP
 #endif
 
 // Tests that enabling HPKP on a domain does not affect the HSTS
 // validity/expiration.
 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKP) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
+                                      ssl_options,
+                                      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
   std::string test_server_hostname = https_test_server.GetURL("").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hpkp-headers.html"), DEFAULT_PRIORITY,
       &d));
   request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(test_server_hostname,
                                                     &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_DEFAULT,
             domain_state.sts.upgrade_mode);
   EXPECT_FALSE(domain_state.sts.include_subdomains);
   EXPECT_FALSE(domain_state.pkp.include_subdomains);
   EXPECT_TRUE(domain_state.HasPublicKeyPins());
   EXPECT_NE(domain_state.sts.expiry, domain_state.pkp.expiry);
 }
 
 TEST_F(URLRequestTestHTTP, PKPNotProcessedOnIP) {
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::SSLOptions(),
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
+                                      SpawnedTestServer::SSLOptions(),
+                                      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
   // Make sure this test fails if the test server is changed to not
   // listen on an IP by default.
   ASSERT_TRUE(https_test_server.GetURL("").HostIsIPAddress());
   std::string test_server_hostname = https_test_server.GetURL("").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hpkp-headers.html"), DEFAULT_PRIORITY,
       &d));
   request->Start();
   base::RunLoop().Run();
 
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_FALSE(security_state->GetDynamicDomainState(test_server_hostname,
                                                      &domain_state));
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTSOnce) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
+                                      ssl_options,
+                                      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
   std::string test_server_hostname = https_test_server.GetURL("").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-multiple-headers.html"),
       DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
 
   // We should have set parameters from the first header, not the second.
   TransportSecurityState* security_state =
       default_context_.transport_security_state();
   TransportSecurityState::DomainState domain_state;
   EXPECT_TRUE(security_state->GetDynamicDomainState(test_server_hostname,
                                                     &domain_state));
   EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS,
             domain_state.sts.upgrade_mode);
   EXPECT_FALSE(domain_state.sts.include_subdomains);
   EXPECT_FALSE(domain_state.pkp.include_subdomains);
 }
 
 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
+                                      ssl_options,
+                                      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
   std::string test_server_hostname = https_test_server.GetURL("").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-and-hpkp-headers.html"),
       DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
@@ skipping 18 matching lines @@
   EXPECT_FALSE(domain_state.sts.include_subdomains);
   // includeSubdomains does not occur in the test HPKP header.
   EXPECT_FALSE(domain_state.pkp.include_subdomains);
 }
 
 // Tests that when multiple HPKP headers are present, asserting different
 // policies, that only the first such policy is processed.
 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP2) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
-  SpawnedTestServer https_test_server(
-      SpawnedTestServer::TYPE_HTTPS,
-      ssl_options,
-      base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest")));
+  SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
+                                      ssl_options,
+                                      base::FilePath(kTestFilePath));
   ASSERT_TRUE(https_test_server.Start());
 
   std::string test_server_hostname = https_test_server.GetURL("").host();
 
   TestDelegate d;
   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
       https_test_server.GetURL("files/hsts-and-hpkp-headers2.html"),
       DEFAULT_PRIORITY, &d));
   request->Start();
   base::RunLoop().Run();
@@ skipping 500 matching lines @@
 
     req->FollowDeferredRedirect();
     base::RunLoop().Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
-    path = path.Append(FILE_PATH_LITERAL("net"));
-    path = path.Append(FILE_PATH_LITERAL("data"));
-    path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+    path = path.Append(kTestFilePath);
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
 
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, DeferredRedirect_GetFullRequestHeaders) {
   ASSERT_TRUE(test_server_.Start());
@@ skipping 20 matching lines @@
 
     GURL target_url(test_server_.GetURL("files/with-headers.html"));
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_TRUE(d.have_full_request_headers());
     CheckFullRequestHeaders(d.full_request_headers(), target_url);
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
 
     base::FilePath path;
     PathService::Get(base::DIR_SOURCE_ROOT, &path);
-    path = path.Append(FILE_PATH_LITERAL("net"));
-    path = path.Append(FILE_PATH_LITERAL("data"));
-    path = path.Append(FILE_PATH_LITERAL("url_request_unittest"));
+    path = path.Append(kTestFilePath);
     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
 
     std::string contents;
     EXPECT_TRUE(base::ReadFileToString(path, &contents));
     EXPECT_EQ(contents, d.data_received());
   }
 }
 
 TEST_F(URLRequestTestHTTP, CancelDeferredRedirect) {
   ASSERT_TRUE(test_server_.Start());
@@ skipping 950 matching lines @@
 
 class URLRequestTestReferrerPolicy : public URLRequestTest {
  public:
   URLRequestTestReferrerPolicy() {}
 
   void InstantiateSameOriginServers(SpawnedTestServer::Type origin_type) {
     origin_server_.reset(new SpawnedTestServer(
         origin_type, SpawnedTestServer::kLocalhost,
         origin_type == SpawnedTestServer::TYPE_HTTPS
             ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
-            : base::FilePath(
-                  FILE_PATH_LITERAL("net/data/url_request_unittest"))));
+            : base::FilePath(kTestFilePath)));
     ASSERT_TRUE(origin_server_->Start());
   }
 
   void InstantiateCrossOriginServers(SpawnedTestServer::Type origin_type,
                                      SpawnedTestServer::Type destination_type) {
     origin_server_.reset(new SpawnedTestServer(
         origin_type, SpawnedTestServer::kLocalhost,
         origin_type == SpawnedTestServer::TYPE_HTTPS
             ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
-            : base::FilePath(
-                  FILE_PATH_LITERAL("net/data/url_request_unittest"))));
+            : base::FilePath(kTestFilePath)));
     ASSERT_TRUE(origin_server_->Start());
 
     destination_server_.reset(new SpawnedTestServer(
         destination_type, SpawnedTestServer::kLocalhost,
         destination_type == SpawnedTestServer::TYPE_HTTPS
             ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
-            : base::FilePath(
-                  FILE_PATH_LITERAL("net/data/url_request_unittest"))));
+            : base::FilePath(kTestFilePath)));
     ASSERT_TRUE(destination_server_->Start());
   }
 
   void VerifyReferrerAfterRedirect(URLRequest::ReferrerPolicy policy,
                                    const GURL& referrer,
                                    const GURL& expected) {
     // Create and execute the request: we'll only have a |destination_server_|
     // if the origins are meant to be distinct. Otherwise, we'll use the
     // |origin_server_| for both endpoints.
     GURL destination_url =
@@ skipping 1750 matching lines @@
 
   // If the certificate is recorded as revoked in the CRLSet, that should be
   // reflected without online revocation checking.
   EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
   EXPECT_FALSE(
       static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
 }
 #endif  // !defined(OS_IOS)
 
-#if !defined(DISABLE_FTP_SUPPORT)
+#if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
+// These tests aren't passing on Android.  Either the RemoteTestServer isn't
+// starting up successfully, or it can't access the test files.
+// TODO(mmenke):  Fix this.  See http://crbug.com/495220
 class URLRequestTestFTP : public URLRequestTest {
  public:
   URLRequestTestFTP()
-      : test_server_(SpawnedTestServer::TYPE_FTP, SpawnedTestServer::kLocalhost,
-                     base::FilePath()) {
+      : ftp_transaction_factory_(&host_resolver_),
+        test_server_(SpawnedTestServer::TYPE_FTP,
+                     SpawnedTestServer::kLocalhost,
+                     base::FilePath(kTestFilePath)) {
+    // Can't use |default_context_|'s HostResolver to set up the
+    // FTPTransactionFactory because it hasn't been created yet.
+    default_context_.set_host_resolver(&host_resolver_);
+  }
+
+  // URLRequestTest interface:
+  void SetUpFactory() override {
+    // Add FTP support to the default URLRequestContext.
+    job_factory_impl_->SetProtocolHandler(
+        "ftp", new FtpProtocolHandler(&ftp_transaction_factory_));
+  }
+
+  std::string GetTestFileContents() {
+    base::FilePath path;
+    EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &path));
+    path = path.Append(kTestFilePath);
+    path = path.AppendASCII(kFtpTestFile);
+    std::string contents;
+    EXPECT_TRUE(base::ReadFileToString(path, &contents));
+    return contents;
   }
 
  protected:
+  MockHostResolver host_resolver_;
+  FtpNetworkLayer ftp_transaction_factory_;
+
   SpawnedTestServer test_server_;
 };
 
 // Make sure an FTP request using an unsafe ports fails.
 TEST_F(URLRequestTestFTP, UnsafePort) {
-  ASSERT_TRUE(test_server_.Start());
-
-  URLRequestJobFactoryImpl job_factory;
-  FtpNetworkLayer ftp_transaction_factory(default_context_.host_resolver());
-
   GURL url("ftp://127.0.0.1:7");
-  job_factory.SetProtocolHandler(
-      "ftp",
-      new FtpProtocolHandler(&ftp_transaction_factory));
-  default_context_.set_job_factory(&job_factory);
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(
         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
     EXPECT_EQ(ERR_UNSAFE_PORT, r->status().error());
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPDirectoryListing) {
+TEST_F(URLRequestTestFTP, FTPDirectoryListing) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
         test_server_.GetURL("/"), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_LT(0, d.bytes_received());
     EXPECT_EQ(test_server_.host_port_pair().host(),
               r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
               r->GetSocketAddress().port());
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPGetTestAnonymous) {
+TEST_F(URLRequestTestFTP, FTPGetTestAnonymous) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("/LICENSE"), DEFAULT_PRIORITY, &d));
+        test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(GetTestFileContents(), d.data_received());
     EXPECT_EQ(test_server_.host_port_pair().host(),
               r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
               r->GetSocketAddress().port());
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPGetTest) {
+TEST_F(URLRequestTestFTP, FTPGetTest) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
-    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome", "chrome"),
-        DEFAULT_PRIORITY, &d));
+    scoped_ptr<URLRequest> r(
+        default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
+                                           kFtpTestFile, "chrome", "chrome"),
+                                       DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
+    EXPECT_EQ(1, d.response_started_count());
+    EXPECT_FALSE(d.received_data_before_response());
+    EXPECT_EQ(GetTestFileContents(), d.data_received());
     EXPECT_EQ(test_server_.host_port_pair().host(),
               r->GetSocketAddress().host());
     EXPECT_EQ(test_server_.host_port_pair().port(),
               r->GetSocketAddress().port());
-    EXPECT_EQ(1, d.response_started_count());
-    EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
 
     LoadTimingInfo load_timing_info;
     r->GetLoadTimingInfo(&load_timing_info);
     TestLoadTimingNoHttpResponse(load_timing_info);
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPassword) {
+TEST_F(URLRequestTestFTP, FTPCheckWrongPassword) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome",
+        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
                                                "wrong_password"),
         DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPasswordRestart) {
+TEST_F(URLRequestTestFTP, FTPCheckWrongPasswordRestart) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   // Set correct login credentials. The delegate will be asked for them when
   // the initial login with wrong credentials will fail.
   d.set_credentials(AuthCredentials(kChrome, kChrome));
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome",
+        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
                                                "wrong_password"),
         DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(GetTestFileContents(), d.data_received());
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongUser) {
+TEST_F(URLRequestTestFTP, FTPCheckWrongUser) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   {
-    scoped_ptr<URLRequest> r(
-        default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
-                                           "/LICENSE", "wrong_user", "chrome"),
-                                       DEFAULT_PRIORITY, &d));
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
+                                               "chrome"),
+        DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), 0);
+    EXPECT_EQ(0, d.bytes_received());
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongUserRestart) {
+TEST_F(URLRequestTestFTP, FTPCheckWrongUserRestart) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
   TestDelegate d;
   // Set correct login credentials. The delegate will be asked for them when
   // the initial login with wrong credentials will fail.
   d.set_credentials(AuthCredentials(kChrome, kChrome));
   {
-    scoped_ptr<URLRequest> r(
-        default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
-                                           "/LICENSE", "wrong_user", "chrome"),
-                                       DEFAULT_PRIORITY, &d));
+    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
+        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
+                                               "chrome"),
+        DEFAULT_PRIORITY, &d));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
-    EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(GetTestFileContents(), d.data_received());
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPCacheURLCredentials) {
+TEST_F(URLRequestTestFTP, FTPCacheURLCredentials) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
-
   scoped_ptr<TestDelegate> d(new TestDelegate);
   {
     // Pass correct login identity in the URL.
-    scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome", "chrome"),
-        DEFAULT_PRIORITY, d.get()));
+    scoped_ptr<URLRequest> r(
+        default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
+                                           kFtpTestFile, "chrome", "chrome"),
+                                       DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
-    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
 
   d.reset(new TestDelegate);
   {
     // This request should use cached identity from previous request.
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("/LICENSE"), DEFAULT_PRIORITY, d.get()));
+        test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
-    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
 }
 
-// Flaky, see http://crbug.com/25045.
-TEST_F(URLRequestTestFTP, DISABLED_FTPCacheLoginBoxCredentials) {
+TEST_F(URLRequestTestFTP, FTPCacheLoginBoxCredentials) {
   ASSERT_TRUE(test_server_.Start());
 
-  base::FilePath app_path;
-  PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
-  app_path = app_path.AppendASCII("LICENSE");
-
   scoped_ptr<TestDelegate> d(new TestDelegate);
   // Set correct login credentials. The delegate will be asked for them when
   // the initial login with wrong credentials will fail.
   d->set_credentials(AuthCredentials(kChrome, kChrome));
   {
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome",
+        test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
                                                "wrong_password"),
         DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
-    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
 
   // Use a new delegate without explicit credentials. The cached ones should be
   // used.
   d.reset(new TestDelegate);
   {
     // Don't pass wrong credentials in the URL, they would override valid cached
     // ones.
     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
-        test_server_.GetURL("/LICENSE"), DEFAULT_PRIORITY, d.get()));
+        test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 file_size = 0;
-    base::GetFileSize(app_path, &file_size);
-
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
-    EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
+    EXPECT_EQ(GetTestFileContents(), d->data_received());
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 TEST_F(URLRequestTest, NetworkAccessedClearBeforeNetworkStart) {
   TestDelegate d;
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   d.set_quit_on_network_start(true);
 
@@ skipping 38 matching lines @@
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
 
   EXPECT_FALSE(req->response_info().network_accessed);
 
   req->Start();
   base::RunLoop().Run();
   EXPECT_TRUE(req->response_info().network_accessed);
 }
 
 }  // namespace net