Allow URLRequests from one context to have different NetworkDelegates.

chrome/browser/chromeos/drive/drive_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/drive/drive_url_request_job.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
 #include "chrome/browser/chromeos/drive/fake_file_system.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/test_util.h"
 #include "chrome/browser/drive/fake_drive_service.h"
 #include "chrome/browser/drive/test_util.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/drive/test_util.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_byte_range.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace drive {
 namespace {
 
 // A simple URLRequestJobFactory implementation to create DriveURLRequestJob.
 class TestURLRequestJobFactory : public net::URLRequestJobFactory {
  public:
@@ skipping 38 matching lines @@
 
 class TestDelegate : public net::TestDelegate {
  public:
   TestDelegate() {}
 
   const GURL& redirect_url() const { return redirect_url_; }
 
   // net::TestDelegate override.
   virtual void OnReceivedRedirect(net::URLRequest* request,
                                   const GURL& new_url,
-                                  bool* defer_redirect) OVERRIDE{
+                                  bool* defer_redirect) OVERRIDE {
     redirect_url_ = new_url;
     net::TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect);
   }
 
  private:
   GURL redirect_url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
@@ skipping 79 matching lines @@
   scoped_ptr<FakeDriveService> fake_drive_service_;
   scoped_ptr<test_util::FakeFileSystem> fake_file_system_;
 
   scoped_ptr<net::TestNetworkDelegate> test_network_delegate_;
   scoped_ptr<TestURLRequestJobFactory> test_url_request_job_factory_;
   scoped_ptr<net::URLRequestContext> url_request_context_;
   scoped_ptr<TestDelegate> test_delegate_;
 };
 
 TEST_F(DriveURLRequestJobTest, NonGetMethod) {
-  net::URLRequest request(GURL("drive:drive/root/File 1.txt"),
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
-  request.set_method("POST");  // Set non "GET" method.
-  request.Start();
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      GURL("drive:drive/root/File 1.txt"),
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
+  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::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_METHOD_NOT_SUPPORTED, request->status().error());
 }
 
 TEST_F(DriveURLRequestJobTest, RegularFile) {
   const GURL kTestUrl("drive:drive/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.
   {
-    net::URLRequest request(kTestUrl,
-                            net::DEFAULT_PRIORITY,
-                            test_delegate_.get(),
-                            url_request_context_.get());
-    request.Start();
+    scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+        kTestUrl,
+        net::DEFAULT_PRIORITY,
+        test_delegate_.get(),
+        NULL));
+    request->Start();
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
+    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().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);
+    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);
-    net::URLRequest request(GURL("drive:drive/root/File 1.txt"),
-                            net::DEFAULT_PRIORITY,
-                            test_delegate_.get(),
-                            url_request_context_.get());
-    request.Start();
+    scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+        GURL("drive:drive/root/File 1.txt"),
+        net::DEFAULT_PRIORITY,
+        test_delegate_.get(),
+        NULL));
+    request->Start();
 
     base::RunLoop().Run();
 
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
+    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
     std::string mime_type;
-    request.GetMimeType(&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(DriveURLRequestJobTest, HostedDocument) {
   // Open a gdoc file.
   test_delegate_->set_quit_on_redirect(true);
-  net::URLRequest request(
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
       GURL("drive:drive/root/Document 1 excludeDir-test.gdoc"),
       net::DEFAULT_PRIORITY,
       test_delegate_.get(),
-      url_request_context_.get());
-  request.Start();
+      NULL));
+  request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
   // Make sure that a hosted document triggers redirection.
-  EXPECT_TRUE(request.is_redirecting());
+  EXPECT_TRUE(request->is_redirecting());
   EXPECT_TRUE(test_delegate_->redirect_url().is_valid());
 }
 
 TEST_F(DriveURLRequestJobTest, RootDirectory) {
-  net::URLRequest request(GURL("drive:drive/root"),
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
-  request.Start();
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      GURL("drive:drive/root"),
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
+  request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status());
-  EXPECT_EQ(net::ERR_FAILED, request.status().error());
+  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_FAILED, request->status().error());
 }
 
 TEST_F(DriveURLRequestJobTest, Directory) {
-  net::URLRequest request(GURL("drive:drive/root/Directory 1"),
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
-  request.Start();
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      GURL("drive:drive/root/Directory 1"),
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
+  request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status());
-  EXPECT_EQ(net::ERR_FAILED, request.status().error());
+  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_FAILED, request->status().error());
 }
 
 TEST_F(DriveURLRequestJobTest, NonExistingFile) {
-  net::URLRequest request(GURL("drive:drive/root/non-existing-file.txt"),
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
-  request.Start();
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      GURL("drive:drive/root/non-existing-file.txt"),
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
+  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::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_FILE_NOT_FOUND, request->status().error());
 }
 
 TEST_F(DriveURLRequestJobTest, WrongFormat) {
-  net::URLRequest request(GURL("drive:"),
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
-  request.Start();
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      GURL("drive:"),
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
+  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::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_INVALID_URL, request->status().error());
 }
 
 TEST_F(DriveURLRequestJobTest, Cancel) {
-  net::URLRequest request(GURL("drive:drive/root/File 1.txt"),
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      GURL("drive:drive/root/File 1.txt"),
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
 
   // Start the request, and cancel it immediately after it.
-  request.Start();
-  request.Cancel();
+  request->Start();
+  request->Cancel();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, request.status().status());
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, request->status().status());
 }
 
 TEST_F(DriveURLRequestJobTest, RangeHeader) {
   const GURL kTestUrl("drive:drive/root/File 1.txt");
   const base::FilePath kTestFilePath("drive/root/File 1.txt");
 
-  net::URLRequest request(kTestUrl,
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      kTestUrl,
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
 
   // Set range header.
-  request.SetExtraRequestHeaderByName(
+  request->SetExtraRequestHeaderByName(
       "Range", "bytes=3-5", false /* overwrite */);
-  request.Start();
+  request->Start();
 
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
+  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().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(DriveURLRequestJobTest, WrongRangeHeader) {
   const GURL kTestUrl("drive:drive/root/File 1.txt");
 
-  net::URLRequest request(kTestUrl,
-                          net::DEFAULT_PRIORITY,
-                          test_delegate_.get(),
-                          url_request_context_.get());
+  scoped_ptr<net::URLRequest> request(url_request_context_->CreateRequest(
+      kTestUrl,
+      net::DEFAULT_PRIORITY,
+      test_delegate_.get(),
+      NULL));
 
   // Set range header.
-  request.SetExtraRequestHeaderByName(
+  request->SetExtraRequestHeaderByName(
       "Range", "Wrong Range Header Value", false /* overwrite */);
-  request.Start();
+  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::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, request->status().error());
 }
 
 }  // namespace drive