Implement ResourceQueue, an object that makes it easy to delay starting

chrome/browser/renderer_host/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2006-2008 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/file_path.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "chrome/browser/child_process_security_policy.h"
@@ skipping 130 matching lines @@
   ResourceDispatcherHost::Receiver* dest_;
 
   DISALLOW_COPY_AND_ASSIGN(ForwardingReceiver);
 };
 
 class ResourceDispatcherHostTest : public testing::Test,
                                    public ResourceDispatcherHost::Receiver {
  public:
   ResourceDispatcherHostTest()
       : Receiver(ChildProcessInfo::RENDER_PROCESS, -1),
+        ui_thread_(ChromeThread::UI, &message_loop_),
         io_thread_(ChromeThread::IO, &message_loop_),
         old_factory_(NULL) {
     set_handle(base::GetCurrentProcessHandle());
   }
   // ResourceDispatcherHost::Receiver implementation
   virtual bool Send(IPC::Message* msg) {
     accum_.AddMessage(*msg);
     delete msg;
     return true;
   }
 
   URLRequestContext* GetRequestContext(
       uint32 request_id,
       const ViewHostMsg_Resource_Request& request_data) {
     return NULL;
   }
 
  protected:
   // testing::Test
   virtual void SetUp() {
     DCHECK(!test_fixture_);
     test_fixture_ = this;
     ChildProcessSecurityPolicy::GetInstance()->Add(0);
     URLRequest::RegisterProtocolFactory("test",
                                         &ResourceDispatcherHostTest::Factory);
     EnsureTestSchemeIsAllowed();
   }
+
   virtual void TearDown() {
     URLRequest::RegisterProtocolFactory("test", NULL);
     if (!scheme_.empty())
       URLRequest::RegisterProtocolFactory(scheme_, old_factory_);
 
     DCHECK(test_fixture_ == this);
     test_fixture_ = NULL;
 
     ChildProcessSecurityPolicy::GetInstance()->Remove(0);
 
@@ skipping 50 matching lines @@
                                 const std::string& scheme) {
     if (test_fixture_->response_headers_.empty()) {
       return new URLRequestTestJob(request);
     } else {
       return new URLRequestTestJob(request, test_fixture_->response_headers_,
                                    test_fixture_->response_data_, false);
     }
   }
 
   MessageLoopForIO message_loop_;
+  ChromeThread ui_thread_;
   ChromeThread io_thread_;
   ResourceDispatcherHost host_;
   ResourceIPCAccumulator accum_;
   std::string response_headers_;
   std::string response_data_;
   std::string scheme_;
   URLRequest::ProtocolFactory* old_factory_;
   static ResourceDispatcherHostTest* test_fixture_;
 };
 // Static.
@@ skipping 613 matching lines @@
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("text/plain", response_head.mime_type);
 }