Adjust callers and networking delegates in chrome/ to modified APIs

chrome/browser/chromeos/fileapi/external_file_url_request_job_unittest.cc

 // Copyright 2013 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 "chrome/browser/chromeos/fileapi/external_file_url_request_job.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 90 matching lines @@
  public:
   TestDelegate() {}
 
   const GURL& redirect_url() const { return redirect_url_; }
 
   // net::TestDelegate override.
   void OnReceivedRedirect(net::URLRequest* request,
                           const net::RedirectInfo& redirect_info,
                           bool* defer_redirect) override {
     redirect_url_ = redirect_info.new_url;
-    net::TestDelegate::OnReceivedRedirect(
-        request, redirect_info, defer_redirect);
+    net::TestDelegate::OnReceivedRedirect(request, redirect_info,
+                                          defer_redirect);
   }
 
  private:
   GURL redirect_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
 }  // namespace
 
@@ skipping 119 matching lines @@
 
 TEST_F(ExternalFileURLRequestJobTest, NonGetMethod) {
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/File 1.txt"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->set_method("POST");  // Set non "GET" method.
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
-  EXPECT_EQ(net::ERR_METHOD_NOT_SUPPORTED, request->status().error());
+  EXPECT_EQ(net::ERR_METHOD_NOT_SUPPORTED, test_dalegate_.request_status());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, RegularFile) {
   const GURL kTestUrl("externalfile:drive-test-user-hash/root/File 1.txt");
   const base::FilePath kTestFilePath("drive/root/File 1.txt");
 
   // For the first time, the file should be fetched from the server.
   {
     std::unique_ptr<net::URLRequest> request(
         url_request_context_->CreateRequest(kTestUrl, net::DEFAULT_PRIORITY,
                                             test_delegate_.get()));
     request->Start();
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+    EXPECT_EQ(net::OK, test_dalegate_.request_status());
     // It looks weird, but the mime type for the "File 1.txt" is "audio/mpeg"
     // on the server.
     std::string mime_type;
     request->GetMimeType(&mime_type);
     EXPECT_EQ("audio/mpeg", mime_type);
 
     // Reading file must be done after |request| runs, otherwise
     // it'll create a local cache file, and we cannot test correctly.
     std::string expected_data;
     ASSERT_TRUE(ReadDriveFileSync(kTestFilePath, &expected_data));
     EXPECT_EQ(expected_data, test_delegate_->data_received());
   }
 
   // For the second time, the locally cached file should be used.
   // The caching emulation is done by FakeFileSystem.
   {
     test_delegate_.reset(new TestDelegate);
     std::unique_ptr<net::URLRequest> request(
         url_request_context_->CreateRequest(
             GURL("externalfile:drive-test-user-hash/root/File 1.txt"),
             net::DEFAULT_PRIORITY, test_delegate_.get()));
     request->Start();
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+    EXPECT_EQ(net::OK, test_dalegate_.request_status());
+
     std::string mime_type;
     request->GetMimeType(&mime_type);
     EXPECT_EQ("audio/mpeg", mime_type);
 
     std::string expected_data;
     ASSERT_TRUE(ReadDriveFileSync(kTestFilePath, &expected_data));
     EXPECT_EQ(expected_data, test_delegate_->data_received());
   }
 }
 
 TEST_F(ExternalFileURLRequestJobTest, HostedDocument) {
   // Open a gdoc file.
   test_delegate_->set_quit_on_redirect(true);
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/Document 1 "
            "excludeDir-test.gdoc"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_EQ(net::OK, test_dalegate_.request_status());
   // Make sure that a hosted document triggers redirection.
   EXPECT_TRUE(request->is_redirecting());
   EXPECT_TRUE(test_delegate_->redirect_url().is_valid());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, RootDirectory) {
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root"), net::DEFAULT_PRIORITY,
       test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
-  EXPECT_EQ(net::ERR_FAILED, request->status().error());
+  EXPECT_EQ(net::ERR_FAILED, test_dalegate_.request_status());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, Directory) {
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/Directory 1"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
-  EXPECT_EQ(net::ERR_FAILED, request->status().error());
+  EXPECT_EQ(net::ERR_FAILED, test_dalegate_.request_status());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, NonExistingFile) {
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/non-existing-file.txt"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
-  EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request->status().error());
+  EXPECT_EQ(net::ERR_FILE_NOT_FOUND, test_dalegate_.request_status());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, WrongFormat) {
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:"), net::DEFAULT_PRIORITY, test_delegate_.get()));
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
-  EXPECT_EQ(net::ERR_INVALID_URL, request->status().error());
+  EXPECT_EQ(net::ERR_INVALID_URL, test_dalegate_.request_status());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, Cancel) {
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("externalfile:drive-test-user-hash/root/File 1.txt"),
       net::DEFAULT_PRIORITY, test_delegate_.get()));
 
   // Start the request, and cancel it immediately after it.
   request->Start();
   request->Cancel();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, request->status().status());
+  EXPECT_EQ(net::ERR_ABORTED, test_dalegate_.request_status());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, RangeHeader) {
   const GURL kTestUrl("externalfile:drive-test-user-hash/root/File 1.txt");
   const base::FilePath kTestFilePath("drive/root/File 1.txt");
 
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       kTestUrl, net::DEFAULT_PRIORITY, test_delegate_.get()));
 
   // Set range header.
   request->SetExtraRequestHeaderByName(
       "Range", "bytes=3-5", false /* overwrite */);
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_EQ(net::OK, test_dalegate_.request_status());
 
   // Reading file must be done after |request| runs, otherwise
   // it'll create a local cache file, and we cannot test correctly.
   std::string expected_data;
   ASSERT_TRUE(ReadDriveFileSync(kTestFilePath, &expected_data));
   EXPECT_EQ(expected_data.substr(3, 3), test_delegate_->data_received());
 }
 
 TEST_F(ExternalFileURLRequestJobTest, WrongRangeHeader) {
   const GURL kTestUrl("externalfile:drive-test-user-hash/root/File 1.txt");
 
   std::unique_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       kTestUrl, net::DEFAULT_PRIORITY, test_delegate_.get()));
 
   // Set range header.
   request->SetExtraRequestHeaderByName(
       "Range", "Wrong Range Header Value", false /* overwrite */);
   request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
-  EXPECT_EQ(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, request->status().error());
+  EXPECT_EQ(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, test_delegate_.);
 }
 
 }  // namespace chromeos