(Owner approval for) Delay network requests on startup if any webRequest ...

content/browser/renderer_host/resource_queue_unittest.cc

 // Copyright (c) 2011 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/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/mock_resource_context.h"
 #include "content/browser/renderer_host/dummy_resource_handler.h"
 #include "content/browser/renderer_host/global_request_id.h"
@@ skipping 59 matching lines @@
   }
 
   virtual void Initialize(ResourceQueue* resource_queue) {
     resource_queue_ = resource_queue;
   }
 
   virtual bool ShouldDelayRequest(
       net::URLRequest* request,
       const ResourceDispatcherHostRequestInfo& request_info,
       const GlobalRequestID& request_id) {
-    delayed_requests_.push_back(request_id);
     return true;
   }
 
   virtual void WillShutdownResourceQueue() {
     resource_queue_ = NULL;
   }
 
   void StartDelayedRequests() {
-    if (!resource_queue_)
-      return;
-
-    for (RequestList::iterator i = delayed_requests_.begin();
-         i != delayed_requests_.end(); ++i) {
-      resource_queue_->StartDelayedRequest(this, *i);
-    }
+    if (resource_queue_)
+      resource_queue_->StartDelayedRequests(this);
   }
 
  private:
   typedef std::vector<GlobalRequestID> RequestList;
 
   ResourceQueue* resource_queue_;
 
-  RequestList delayed_requests_;
-
   DISALLOW_COPY_AND_ASSIGN(AlwaysDelayingDelegate);
 };
 
 class ResourceQueueTest : public testing::Test,
                           public net::URLRequest::Delegate {
  public:
   ResourceQueueTest()
       : response_started_count_(0),
         message_loop_(MessageLoop::TYPE_IO),
         ui_thread_(BrowserThread::UI, &message_loop_),
@@ skipping 94 matching lines @@
   queue.AddRequest(&request, *request_info.get());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
   always_delaying_delegate.StartDelayedRequests();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, response_started_count_);
 
   queue.Shutdown();
 }
 
+TEST_F(ResourceQueueTest, TwoDelayingDelegates) {
+  ResourceQueue queue;
+
+  AlwaysDelayingDelegate always_delaying_delegate1;
+  AlwaysDelayingDelegate always_delaying_delegate2;
+  InitializeQueue(
+      &queue, &always_delaying_delegate1, &always_delaying_delegate2);
+
+  net::URLRequest request(GURL(kTestUrl), this);
+  scoped_ptr<ResourceDispatcherHostRequestInfo> request_info(GetRequestInfo(0));
+  EXPECT_EQ(0, response_started_count_);
+  queue.AddRequest(&request, *request_info.get());
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(0, response_started_count_);
+
+  always_delaying_delegate1.StartDelayedRequests();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(0, response_started_count_);
+
+  always_delaying_delegate2.StartDelayedRequests();
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(1, response_started_count_);
+
+  queue.Shutdown();
+}
+
 TEST_F(ResourceQueueTest, RemoveRequest) {
   ResourceQueue queue;
 
   AlwaysDelayingDelegate delegate;
   InitializeQueue(&queue, &delegate);
 
   net::URLRequest request(GURL(kTestUrl), this);
   scoped_ptr<ResourceDispatcherHostRequestInfo> request_info(GetRequestInfo(0));
   GlobalRequestID request_id(request_info->child_id(),
                              request_info->request_id());
   EXPECT_EQ(0, response_started_count_);
   queue.AddRequest(&request, *request_info.get());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
   queue.RemoveRequest(request_id);
   delegate.StartDelayedRequests();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
 
   queue.Shutdown();
 
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
 }
 
 }  // namespace