Adds the new URLRequest::OnBeforeNetworkStart hook to the

content/browser/loader/resource_dispatcher_host_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 <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 192 matching lines @@
     *resource_context = resource_context_;
     *request_context = resource_context_->GetRequestContext();
   }
 
   IPC::Sender* dest_;
   ResourceContext* resource_context_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingFilter);
 };
 
+// This class is a variation on URLRequestTestJob that will call
+// URLRequest::OnBeforeNetworkStart before starting.
+class URLRequestTestDelayedNetworkJob : public net::URLRequestTestJob {
+ public:
+  URLRequestTestDelayedNetworkJob(net::URLRequest* request,
+                                  net::NetworkDelegate* network_delegate)
+      : net::URLRequestTestJob(request, network_delegate) {}
+
+  // Only start if not deferred for network start.
+  virtual void Start() OVERRIDE {
+    bool defer = false;
+    NotifyBeforeNetworkStart(&defer);
+    if (defer)
+      return;
+    net::URLRequestTestJob::Start();
+  }
+
+  virtual void ResumeNetworkStart() OVERRIDE {
+    net::URLRequestTestJob::StartAsync();
+  }
+
+ private:
+  virtual ~URLRequestTestDelayedNetworkJob() {}
+
+  DISALLOW_COPY_AND_ASSIGN(URLRequestTestDelayedNetworkJob);
+};
+
 // This class is a variation on URLRequestTestJob in that it does
 // not complete start upon entry, only when specifically told to.
 class URLRequestTestDelayedStartJob : public net::URLRequestTestJob {
  public:
   URLRequestTestDelayedStartJob(net::URLRequest* request,
                                 net::NetworkDelegate* network_delegate)
       : net::URLRequestTestJob(request, network_delegate) {
     Init();
   }
   URLRequestTestDelayedStartJob(net::URLRequest* request,
@@ skipping 164 matching lines @@
                                               const GURL& current_url,
                                               const GURL& new_url) OVERRIDE {
     return true;
   }
 };
 
 enum GenericResourceThrottleFlags {
   NONE                      = 0,
   DEFER_STARTING_REQUEST    = 1 << 0,
   DEFER_PROCESSING_RESPONSE = 1 << 1,
-  CANCEL_BEFORE_START       = 1 << 2
+  CANCEL_BEFORE_START       = 1 << 2,
+  DEFER_NETWORK_START       = 1 << 3
 };
 
 // Throttle that tracks the current throttle blocking a request.  Only one
 // can throttle any request at a time.
 class GenericResourceThrottle : public ResourceThrottle {
  public:
   // The value is used to indicate that the throttle should not provide
   // a error code when cancelling a request. net::OK is used, because this
   // is not an error code.
   static const int USE_DEFAULT_CANCEL_ERROR_CODE = net::OK;
@@ skipping 26 matching lines @@
   }
 
   virtual void WillProcessResponse(bool* defer) OVERRIDE {
     ASSERT_EQ(NULL, active_throttle_);
     if (flags_ & DEFER_PROCESSING_RESPONSE) {
       active_throttle_ = this;
       *defer = true;
     }
   }
 
+  virtual void OnBeforeNetworkStart(bool* defer) OVERRIDE {
+    ASSERT_EQ(NULL, active_throttle_);
+
+    if (flags_ & DEFER_NETWORK_START) {
+      active_throttle_ = this;
+      *defer = true;
+    }
+  }
+
   virtual const char* GetNameForLogging() const OVERRIDE {
     return "GenericResourceThrottle";
   }
 
   void Resume() {
     ASSERT_TRUE(this == active_throttle_);
     active_throttle_ = NULL;
     controller()->Resume();
   }
 
@@ skipping 112 matching lines @@
   virtual void SetUp() {
     DCHECK(!test_fixture_);
     test_fixture_ = this;
     ChildProcessSecurityPolicyImpl::GetInstance()->Add(0);
     net::URLRequest::Deprecated::RegisterProtocolFactory(
         "test",
         &ResourceDispatcherHostTest::Factory);
     EnsureTestSchemeIsAllowed();
     delay_start_ = false;
     delay_complete_ = false;
+    network_start_notification_ = false;
     url_request_jobs_created_count_ = 0;
   }
 
   virtual void TearDown() {
     net::URLRequest::Deprecated::RegisterProtocolFactory("test", NULL);
     if (!scheme_.empty())
       net::URLRequest::Deprecated::RegisterProtocolFactory(
           scheme_, old_factory_);
 
     EXPECT_TRUE(URLRequestTestDelayedStartJob::DelayedStartQueueEmpty());
@@ skipping 77 matching lines @@
   static net::URLRequestJob* Factory(net::URLRequest* request,
                                      net::NetworkDelegate* network_delegate,
                                      const std::string& scheme) {
     url_request_jobs_created_count_++;
     if (test_fixture_->response_headers_.empty()) {
       if (delay_start_) {
         return new URLRequestTestDelayedStartJob(request, network_delegate);
       } else if (delay_complete_) {
         return new URLRequestTestDelayedCompletionJob(request,
                                                       network_delegate);
+      } else if (network_start_notification_) {
+        return new URLRequestTestDelayedNetworkJob(request, network_delegate);
       } else if (scheme == "big-job") {
         return new URLRequestBigJob(request, network_delegate);
       } else {
         return new net::URLRequestTestJob(request, network_delegate);
       }
     } else {
       if (delay_start_) {
         return new URLRequestTestDelayedStartJob(
             request, network_delegate,
             test_fixture_->response_headers_, test_fixture_->response_data_,
@@ skipping 13 matching lines @@
   }
 
   void SetDelayedStartJobGeneration(bool delay_job_start) {
     delay_start_ = delay_job_start;
   }
 
   void SetDelayedCompleteJobGeneration(bool delay_job_complete) {
     delay_complete_ = delay_job_complete;
   }
 
+  void SetNetworkStartNotificationJobGeneration(bool notification) {
+    network_start_notification_ = notification;
+  }
+
   void GenerateDataReceivedACK(const IPC::Message& msg) {
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msg.type());
 
     int request_id = -1;
     bool result = PickleIterator(msg).ReadInt(&request_id);
     DCHECK(result);
     scoped_ptr<IPC::Message> ack(
         new ResourceHostMsg_DataReceived_ACK(request_id));
 
     base::MessageLoop::current()->PostTask(
@@ skipping 13 matching lines @@
   ResourceIPCAccumulator accum_;
   std::string response_headers_;
   std::string response_data_;
   std::string scheme_;
   net::URLRequest::ProtocolFactory* old_factory_;
   bool send_data_received_acks_;
   std::set<int> child_ids_;
   static ResourceDispatcherHostTest* test_fixture_;
   static bool delay_start_;
   static bool delay_complete_;
+  static bool network_start_notification_;
   static int url_request_jobs_created_count_;
 };
 // Static.
 ResourceDispatcherHostTest* ResourceDispatcherHostTest::test_fixture_ = NULL;
 bool ResourceDispatcherHostTest::delay_start_ = false;
 bool ResourceDispatcherHostTest::delay_complete_ = false;
+bool ResourceDispatcherHostTest::network_start_notification_ = false;
 int ResourceDispatcherHostTest::url_request_jobs_created_count_ = 0;
 
 void ResourceDispatcherHostTest::MakeTestRequest(int render_view_id,
                                                  int request_id,
                                                  const GURL& url) {
   MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id,
                                   url, ResourceType::SUB_RESOURCE);
 }
 
 void ResourceDispatcherHostTest::MakeTestRequestWithResourceType(
@@ skipping 466 matching lines @@
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_error());
   CompleteStartRequest(1);
 
   // flush all the pending requests
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(0, host_.pending_requests());
 }
 
+// Test the OnBeforeNetworkStart throttle.
+TEST_F(ResourceDispatcherHostTest, ThrottleNetworkStart) {
+  // Arrange to have requests deferred before processing response headers.
+  TestResourceDispatcherHostDelegate delegate;
+  delegate.set_flags(DEFER_NETWORK_START);
+  host_.SetDelegate(&delegate);
+
+  SetNetworkStartNotificationJobGeneration(true);
+  MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_2());
+
+  // Should have deferred for network start.
+  GenericResourceThrottle* first_throttle =
+      GenericResourceThrottle::active_throttle();
+  ASSERT_TRUE(first_throttle);
+  EXPECT_EQ(0, network_delegate()->completed_requests());
+  EXPECT_EQ(1, host_.pending_requests());
+
+  first_throttle->Resume();
+
+  // Flush all the pending requests.
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+  base::MessageLoop::current()->RunUntilIdle();
+
+  EXPECT_EQ(1, network_delegate()->completed_requests());
+  EXPECT_EQ(0, host_.pending_requests());
+}
+
 TEST_F(ResourceDispatcherHostTest, ThrottleAndResumeTwice) {
   // Arrange to have requests deferred before starting.
   TestResourceDispatcherHostDelegate delegate;
   delegate.set_flags(DEFER_STARTING_REQUEST);
   delegate.set_create_two_throttles(true);
   host_.SetDelegate(&delegate);
 
   // Make sure the first throttle blocked the request, and then resume.
   MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1());
   GenericResourceThrottle* first_throttle =
@@ skipping 1361 matching lines @@
     }
 
     base::MessageLoop::current()->RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content