Fix transferring processes during a redirect.

content/browser/renderer_host/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 "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/resource_message_filter.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/test/test_browser_context.h"
+#include "content/test/test_content_browser_client.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_simple_job.h"
 #include "net/url_request/url_request_test_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache_interfaces.h"
@@ skipping 87 matching lines @@
   void GetClassifiedMessages(ClassifiedMessages* msgs);
 
  private:
   std::vector<IPC::Message> messages_;
 };
 
 // This is very inefficient as a result of repeatedly extracting the ID, use
 // only for tests!
 void ResourceIPCAccumulator::GetClassifiedMessages(ClassifiedMessages* msgs) {
   while (!messages_.empty()) {
-    std::vector<IPC::Message> cur_requests;
-    cur_requests.push_back(messages_[0]);
+    // Ignore unknown message types as it is valid for code to generated other
+    // IPCs as side-effects that we are not testing here.
     int cur_id = RequestIDForMessage(messages_[0]);
-
-    // find all other messages with this ID
-    for (int i = 1; i < static_cast<int>(messages_.size()); i++) {
-      int id = RequestIDForMessage(messages_[i]);
-      if (id == cur_id) {
-        cur_requests.push_back(messages_[i]);
-        messages_.erase(messages_.begin() + i);
-        i--;
+    if (cur_id != -1) {
+      std::vector<IPC::Message> cur_requests;
+      cur_requests.push_back(messages_[0]);
+      // find all other messages with this ID
+      for (int i = 1; i < static_cast<int>(messages_.size()); i++) {
+        int id = RequestIDForMessage(messages_[i]);
+        if (id == cur_id) {
+          cur_requests.push_back(messages_[i]);
+          messages_.erase(messages_.begin() + i);
+          i--;
+        }
       }
+      msgs->push_back(cur_requests);
     }
     messages_.erase(messages_.begin());
-    msgs->push_back(cur_requests);
   }
 }
 
 class MockURLRequestContextSelector
     : public ResourceMessageFilter::URLRequestContextSelector {
  public:
   explicit MockURLRequestContextSelector(
       net::URLRequestContext* request_context)
       : request_context_(request_context) {}
 
@@ skipping 188 matching lines @@
   }
 
   ~TestUserData() {
     *was_deleted_ = true;
   }
 
  private:
   bool* was_deleted_;
 };
 
+class TransfersAllNavigationsContentBrowserClient
+    : public TestContentBrowserClient {
+ public:
+  virtual bool ShouldSwapProcessesForRedirect(ResourceContext* resource_context,
+                                              const GURL& current_url,
+                                              const GURL& new_url) {
+    return true;
+  }
+};
+
 enum {
   DEFER_NONE                = 0,
   DEFER_STARTING_REQUEST    = 1 << 0,
   DEFER_PROCESSING_RESPONSE = 1 << 1,
 };
 
 class GenericResourceThrottle : public content::ResourceThrottle {
  public:
   GenericResourceThrottle(int defer_flags) : defer_flags_(defer_flags) {
   }
@@ skipping 127 matching lines @@
   // Generates a request using the given filter. This will probably be a
   // ForwardingFilter.
   void MakeTestRequest(ResourceMessageFilter* filter,
                        int render_view_id,
                        int request_id,
                        const GURL& url);
 
   void CancelRequest(int request_id);
 
   void CompleteStartRequest(int request_id);
+  void CompleteStartRequest(ResourceMessageFilter* filter, int request_id);
 
   void EnsureSchemeIsAllowed(const std::string& scheme) {
     ChildProcessSecurityPolicyImpl* policy =
         ChildProcessSecurityPolicyImpl::GetInstance();
     if (!policy->IsWebSafeScheme(scheme))
       policy->RegisterWebSafeScheme(scheme);
   }
 
   void EnsureTestSchemeIsAllowed() {
     EnsureSchemeIsAllowed("test");
   }
 
   // Sets a particular response for any request from now on. To switch back to
   // the default bahavior, pass an empty |headers|. |headers| should be raw-
   // formatted (NULLs instead of EOLs).
   void SetResponse(const std::string& headers, const std::string& data) {
-    response_headers_ = headers;
+    response_headers_ = net::HttpUtil::AssembleRawHeaders(headers.data(),
+                                                          headers.size());
     response_data_ = data;
   }
+  void SetResponse(const std::string& headers) {
+    SetResponse(headers, std::string());
+  }
 
   // Sets a particular resource type for any request from now on.
   void SetResourceType(ResourceType::Type type) {
     resource_type_ = type;
   }
 
   void SendDataReceivedACKs(bool send_acks) {
     send_data_received_acks_ = send_acks;
   }
 
@@ skipping 99 matching lines @@
   bool msg_was_ok;
   host_.OnMessageReceived(msg, filter, &msg_was_ok);
   KickOffRequest();
 }
 
 void ResourceDispatcherHostTest::CancelRequest(int request_id) {
   host_.CancelRequest(filter_->child_id(), request_id, false);
 }
 
 void ResourceDispatcherHostTest::CompleteStartRequest(int request_id) {
-  GlobalRequestID gid(filter_->child_id(), request_id);
+  CompleteStartRequest(filter_, request_id);
+}
+
+void ResourceDispatcherHostTest::CompleteStartRequest(
+    ResourceMessageFilter* filter,
+    int request_id) {
+  GlobalRequestID gid(filter->child_id(), request_id);
   net::URLRequest* req = host_.GetURLRequest(gid);
   EXPECT_TRUE(req);
   if (req)
     URLRequestTestDelayedStartJob::CompleteStart(req);
 }
 
 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 536 matching lines @@
   CheckSuccessfulRequest(msgs[kMaxRequests + 2],
                          net::URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[kMaxRequests + 3],
                          net::URLRequestTestJob::test_data_2());
 }
 
 // Tests that we sniff the mime type for a simple request.
 TEST_F(ResourceDispatcherHostTest, MimeSniffed) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
-  std::string response("HTTP/1.1 200 OK\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
+  std::string raw_headers("HTTP/1.1 200 OK\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   content::ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("text/html", response_head.mime_type);
 }
 
 // Tests that we don't sniff the mime type when the server provides one.
 TEST_F(ResourceDispatcherHostTest, MimeNotSniffed) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
-  std::string response("HTTP/1.1 200 OK\n"
-                       "Content-type: image/jpeg\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
+  std::string raw_headers("HTTP/1.1 200 OK\n"
+                          "Content-type: image/jpeg\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   content::ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("image/jpeg", response_head.mime_type);
 }
 
 // Tests that we don't sniff the mime type when there is no message body.
 TEST_F(ResourceDispatcherHostTest, MimeNotSniffed2) {
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
-  std::string response("HTTP/1.1 304 Not Modified\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
-  std::string response_data;
-  SetResponse(raw_headers, response_data);
+  SetResponse("HTTP/1.1 304 Not Modified\n\n");
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   content::ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("", response_head.mime_type);
 }
 
 TEST_F(ResourceDispatcherHostTest, MimeSniff204) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
-  std::string response("HTTP/1.1 204 No Content\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
-  std::string response_data;
-  SetResponse(raw_headers, response_data);
+  SetResponse("HTTP/1.1 204 No Content\n\n");
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   content::ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("text/plain", response_head.mime_type);
 }
 
 TEST_F(ResourceDispatcherHostTest, MimeSniffEmpty) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
-  std::string response("HTTP/1.1 200 OK\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
-  std::string response_data;
-  SetResponse(raw_headers, response_data);
+  SetResponse("HTTP/1.1 200 OK\n\n");
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
 
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   // Sorts out all the messages we saw by request.
   ResourceIPCAccumulator::ClassifiedMessages msgs;
   accum_.GetClassifiedMessages(&msgs);
   ASSERT_EQ(1U, msgs.size());
 
   content::ResourceResponseHead response_head;
   GetResponseHead(msgs[0], &response_head);
   ASSERT_EQ("text/plain", response_head.mime_type);
 }
 
 // Tests for crbug.com/31266 (Non-2xx + application/octet-stream).
 TEST_F(ResourceDispatcherHostTest, ForbiddenDownload) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
-  std::string response("HTTP/1.1 403 Forbidden\n"
-                       "Content-disposition: attachment; filename=blah\n"
-                       "Content-type: application/octet-stream\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
+  std::string raw_headers("HTTP/1.1 403 Forbidden\n"
+                          "Content-disposition: attachment; filename=blah\n"
+                          "Content-type: application/octet-stream\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   // Only MAIN_FRAMEs can trigger a download.
   SetResourceType(ResourceType::MAIN_FRAME);
 
   HandleScheme("http");
   MakeTestRequest(0, 1, GURL("http:bla"));
 
   // Flush all pending requests.
@@ skipping 25 matching lines @@
 
 // Test for http://crbug.com/76202 .  We don't want to destroy a
 // download request prematurely when processing a cancellation from
 // the renderer.
 TEST_F(ResourceDispatcherHostTest, IgnoreCancelForDownloads) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
-  std::string response("HTTP\n"
-                       "Content-disposition: attachment; filename=foo\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
+  std::string raw_headers("HTTP\n"
+                          "Content-disposition: attachment; filename=foo\n\n");
   std::string response_data("01234567890123456789\x01foobar");
 
   // Get past sniffing metrics in the BufferedResourceHandler.  Note that
   // if we don't get past the sniffing metrics, the result will be that
   // the BufferedResourceHandler won't have figured out that it's a download,
   // won't have constructed a DownloadResourceHandler, and and the request
   // will be successfully canceled below, failing the test.
   response_data.resize(1025, ' ');
 
   SetResponse(raw_headers, response_data);
@@ skipping 19 matching lines @@
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 }
 
 TEST_F(ResourceDispatcherHostTest, CancelRequestsForContext) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
-  std::string response("HTTP\n"
-                       "Content-disposition: attachment; filename=foo\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
+  std::string raw_headers("HTTP\n"
+                          "Content-disposition: attachment; filename=foo\n\n");
   std::string response_data("01234567890123456789\x01foobar");
   // Get past sniffing metrics.
   response_data.resize(1025, ' ');
 
   SetResponse(raw_headers, response_data);
   SetResourceType(ResourceType::MAIN_FRAME);
   SetDelayedCompleteJobGeneration(true);
   HandleScheme("http");
 
   MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
@@ skipping 21 matching lines @@
 }
 
 // Test the cancelling of requests that are being transferred to a new renderer
 // due to a redirection.
 TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextTransferred) {
   EXPECT_EQ(0, host_.pending_requests());
 
   int render_view_id = 0;
   int request_id = 1;
 
-  std::string response("HTTP/1.1 200 OK\n"
-                       "Content-Type: text/html; charset=utf-8\n\n");
-  std::string raw_headers(net::HttpUtil::AssembleRawHeaders(response.data(),
-                                                            response.size()));
+  std::string raw_headers("HTTP/1.1 200 OK\n"
+                          "Content-Type: text/html; charset=utf-8\n\n");
   std::string response_data("<html>foobar</html>");
 
   SetResponse(raw_headers, response_data);
   SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
   MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
 
   GlobalRequestID global_request_id(filter_->child_id(), request_id);
   host_.MarkAsTransferredNavigation(global_request_id);
@@ skipping 10 matching lines @@
 
   // Cancelling by other methods shouldn't work either.
   host_.CancelRequestsForProcess(render_view_id);
   EXPECT_EQ(1, host_.pending_requests());
 
   // Cancelling by context should work.
   host_.CancelRequestsForContext(filter_->resource_context());
   EXPECT_EQ(0, host_.pending_requests());
 }
 
+TEST_F(ResourceDispatcherHostTest, TransferNavigation) {
+  EXPECT_EQ(0, host_.pending_requests());
+
+  int render_view_id = 0;
+  int request_id = 1;
+
+  // Configure initial request.
+  SetResponse("HTTP/1.1 302 Found\n"
+              "Location: http://other.com/blech\n\n");
+
+  SetResourceType(ResourceType::MAIN_FRAME);
+  HandleScheme("http");
+
+  // Temporarily replace ContentBrowserClient with one that will trigger the
+  // transfer navigation code paths.
+  ContentBrowserClient* old_client = GetContentClient()->browser();
+  TransfersAllNavigationsContentBrowserClient new_client;
+  GetContentClient()->set_browser_for_testing(&new_client);
+
+  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+
+  // Restore.
+  GetContentClient()->set_browser_for_testing(old_client);
+
+  // This second filter is used to emulate a second process.
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
+      this, browser_context_->GetResourceContext());
+
+  int new_render_view_id = 1;
+  int new_request_id = 2;
+
+  const std::string kResponseBody = "hello world";
+  SetResponse("HTTP/1.1 200 OK\n"
+              "Content-Type: text/plain\n\n",
+              kResponseBody);
+
+  ResourceHostMsg_Request request =
+      CreateResourceRequest("GET", ResourceType::MAIN_FRAME,
+                            GURL("http://other.com/blech"));
+  request.transferred_request_child_id = filter_->child_id();
+  request.transferred_request_request_id = request_id;
+
+  ResourceHostMsg_RequestResource transfer_request_msg(
+      new_render_view_id, new_request_id, request);
+  bool msg_was_ok;
+  host_.OnMessageReceived(transfer_request_msg, second_filter, &msg_was_ok);
+  MessageLoop::current()->RunAllPending();
+
+  // Flush all the pending requests.
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+
+  // Check generated messages.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  ASSERT_EQ(1U, msgs.size());
+  CheckSuccessfulRequest(msgs[0], kResponseBody);
+}
+
+TEST_F(ResourceDispatcherHostTest, TransferNavigationAndThenRedirect) {
+  EXPECT_EQ(0, host_.pending_requests());
+
+  int render_view_id = 0;
+  int request_id = 1;
+
+  // Configure initial request.
+  SetResponse("HTTP/1.1 302 Found\n"
+              "Location: http://other.com/blech\n\n");
+
+  SetResourceType(ResourceType::MAIN_FRAME);
+  HandleScheme("http");
+
+  // Temporarily replace ContentBrowserClient with one that will trigger the
+  // transfer navigation code paths.
+  ContentBrowserClient* old_client = GetContentClient()->browser();
+  TransfersAllNavigationsContentBrowserClient new_client;
+  GetContentClient()->set_browser_for_testing(&new_client);
+
+  MakeTestRequest(render_view_id, request_id, GURL("http://example.com/blah"));
+
+  // Restore.
+  GetContentClient()->set_browser_for_testing(old_client);
+
+  // This second filter is used to emulate a second process.
+  scoped_refptr<ForwardingFilter> second_filter = new ForwardingFilter(
+      this, browser_context_->GetResourceContext());
+
+  int new_render_view_id = 1;
+  int new_request_id = 2;
+
+  // Delay the start of the next request so that we can setup the response for
+  // the next URL.
+  SetDelayedStartJobGeneration(true);
+
+  SetResponse("HTTP/1.1 302 Found\n"
+              "Location: http://other.com/blerg\n\n");
+
+  ResourceHostMsg_Request request =
+      CreateResourceRequest("GET", ResourceType::MAIN_FRAME,
+                            GURL("http://other.com/blech"));
+  request.transferred_request_child_id = filter_->child_id();
+  request.transferred_request_request_id = request_id;
+
+  ResourceHostMsg_RequestResource transfer_request_msg(
+      new_render_view_id, new_request_id, request);
+  bool msg_was_ok;
+  host_.OnMessageReceived(transfer_request_msg, second_filter, &msg_was_ok);
+  MessageLoop::current()->RunAllPending();
+
+  // Response data for "http://other.com/blerg":
+  const std::string kResponseBody = "hello world";
+  SetResponse("HTTP/1.1 200 OK\n"
+              "Content-Type: text/plain\n\n",
+              kResponseBody);
+
+  // OK, let the redirect happen.
+  SetDelayedStartJobGeneration(false);
+  CompleteStartRequest(second_filter, new_request_id);
+  MessageLoop::current()->RunAllPending();
+
+  // Flush all the pending requests.
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+
+  // Now, simulate the renderer choosing to follow the redirect.
+  ResourceHostMsg_FollowRedirect redirect_msg(
+      new_render_view_id, new_request_id, false, GURL());
+  host_.OnMessageReceived(redirect_msg, second_filter, &msg_was_ok);
+  MessageLoop::current()->RunAllPending();
+
+  // Flush all the pending requests.
+  while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
+
+  // Check generated messages.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  ASSERT_EQ(1U, msgs.size());
+
+  // We should have received a redirect followed by a "normal" payload.
+  EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type());
+  msgs[0].erase(msgs[0].begin());
+  CheckSuccessfulRequest(msgs[0], kResponseBody);
+}
+
 TEST_F(ResourceDispatcherHostTest, UnknownURLScheme) {
   EXPECT_EQ(0, host_.pending_requests());
 
   SetResourceType(ResourceType::MAIN_FRAME);
   HandleScheme("http");
 
   MakeTestRequest(0, 1, GURL("foo://bar"));
 
   // Flush all pending requests.
   while (net::URLRequestTestJob::ProcessOnePendingMessage()) {}
@@ skipping 78 matching lines @@
     }
 
     MessageLoop::current()->RunAllPending();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content