Fix single-process ui test failures from my previous change. The problem was...

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/message_loop.h"
 #include "base/process_util.h"
 #include "chrome/browser/renderer_host/renderer_security_policy.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
@@ skipping 69 matching lines @@
     }
     messages_.erase(messages_.begin());
     msgs->push_back(cur_requests);
   }
 }
 
 class ResourceDispatcherHostTest : public testing::Test,
                                    public ResourceDispatcherHost::Receiver {
  public:
   ResourceDispatcherHostTest()
-      : Receiver(ChildProcessInfo::RENDER_PROCESS), host_(NULL) {
+      : Receiver(ChildProcessInfo::RENDER_PROCESS), host_(NULL), pid_(-1) {
     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;
   }
 
+  virtual int GetProcessId() const { return pid_; }
+
  protected:
   // testing::Test
   virtual void SetUp() {
     RendererSecurityPolicy::GetInstance()->Add(0);
     URLRequest::RegisterProtocolFactory("test", &URLRequestTestJob::Factory);
     EnsureTestSchemeIsAllowed();
   }
   virtual void TearDown() {
     URLRequest::RegisterProtocolFactory("test", NULL);
     RendererSecurityPolicy::GetInstance()->Remove(0);
@@ skipping 22 matching lines @@
 
     if (!have_white_listed_test_scheme) {
       RendererSecurityPolicy::GetInstance()->RegisterWebSafeScheme("test");
       have_white_listed_test_scheme = true;
     }
   }
 
   MessageLoopForIO message_loop_;
   ResourceDispatcherHost host_;
   ResourceIPCAccumulator accum_;
+  int pid_;
 };
 
 // Spin up the message loop to kick off the request.
 static void KickOffRequest() {
   MessageLoop::current()->RunAllPending();
 }
 
 void ResourceDispatcherHostTest::MakeTestRequest(int render_process_id,
                                                  int render_view_id,
                                                  int request_id,
                                                  const GURL& url) {
   MakeTestRequest(this, render_process_id, render_view_id, request_id, url);
 }
 
 void ResourceDispatcherHostTest::MakeTestRequest(
   ResourceDispatcherHost::Receiver* receiver,
     int render_process_id,
     int render_view_id,
     int request_id,
     const GURL& url) {
-  int old_pid = pid();
   pid_ = render_process_id;
   ViewHostMsg_Resource_Request request = CreateResourceRequest("GET", url);
   ViewHostMsg_RequestResource msg(render_view_id, request_id, request);
   bool msg_was_ok;
   host_.OnMessageReceived(msg, receiver, &msg_was_ok);
   KickOffRequest();
-  pid_ = old_pid;
+  pid_ = -1;
 }
 
 void ResourceDispatcherHostTest::MakeCancelRequest(int request_id) {
   host_.CancelRequest(0, request_id, false);
 }
 
 void CheckSuccessfulRequest(const std::vector<IPC::Message>& messages,
                             const std::string& reference_data) {
   // A successful request will have received 4 messages:
   //     ReceivedResponse    (indicates headers received)
@@ skipping 453 matching lines @@
     EXPECT_EQ(URLRequestStatus::CANCELED, status.status());
     EXPECT_EQ(net::ERR_INSUFFICIENT_RESOURCES, status.os_error());
   }
 
   // The final 2 requests should have succeeded.
   CheckSuccessfulRequest(msgs[kMaxRequests + 2],
                          URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[kMaxRequests + 3],
                          URLRequestTestJob::test_data_2());
 }