Fix renderer process host backgrounding test on Windows.

chrome/browser/renderer_host/render_process_host_chrome_browsertest.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 "base/command_line.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_switches.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/test/browser_test_utils.h"
 
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 namespace {
 
 int RenderProcessHostCount() {
   content::RenderProcessHost::iterator hosts =
       content::RenderProcessHost::AllHostsIterator();
@@ skipping 31 matching lines @@
 
   // Show a tab, activating the current one if there is one, and wait for
   // the renderer process to be created or foregrounded, returning the process
   // handle.
   base::ProcessHandle ShowSingletonTab(const GURL& page) {
     chrome::ShowSingletonTab(browser(), page);
     WebContents* wc = browser()->tab_strip_model()->GetActiveWebContents();
     CHECK(wc->GetURL() == page);
 
     WaitForLauncherThread();
+    WaitForMessageProcessing(wc);
     return wc->GetRenderProcessHost()->GetHandle();
   }
 
   // Loads the given url in a new background tab and returns the handle of its
   // renderer.
   base::ProcessHandle OpenBackgroundTab(const GURL& page) {
     ui_test_utils::NavigateToURLWithDisposition(browser(), page,
         NEW_BACKGROUND_TAB, ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 
     TabStripModel* tab_strip = browser()->tab_strip_model();
     WebContents* wc = tab_strip->GetWebContentsAt(
         tab_strip->active_index() + 1);
     CHECK(wc->GetVisibleURL() == page);
 
     WaitForLauncherThread();
+    WaitForMessageProcessing(wc);
     return wc->GetRenderProcessHost()->GetHandle();
   }
 
   // Ensures that the backgrounding / foregrounding gets a chance to run.
   void WaitForLauncherThread() {
     content::BrowserThread::PostTaskAndReply(
         content::BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
         base::Bind(&base::DoNothing), base::MessageLoop::QuitClosure());
     base::MessageLoop::current()->Run();
   }
 
+  // Implicitly waits for the given WebContents to process outstanding IPC
+  // messages by running some JavaScript and waiting for the result.

[jam, 2014/06/04 01:06:05]

this comment is a bit misleading; afaik you're waiting for the renderer to
process an IPC, and not a WebContents (browser process) right? if so, adjust the
comment to say that this ensures that the renderer processed the IPC to set
itself to be backgrounded

[DaleCurtis, 2014/06/04 01:10:18]

Done.

+  void WaitForMessageProcessing(WebContents* wc) {
+    bool result = false;
+    ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
+        wc, "window.domAutomationController.send(true);", &result));
+    ASSERT_TRUE(result);
+  }
+
   // When we hit the max number of renderers, verify that the way we do process
   // sharing behaves correctly.  In particular, this test is verifying that even
   // when we hit the max process limit, that renderers of each type will wind up
   // in a process of that type, even if that means creating a new process.
   void TestProcessOverflow() {
     int tab_count = 1;
     int host_count = 1;
     WebContents* tab1 = NULL;
     WebContents* tab2 = NULL;
     content::RenderProcessHost* rph1 = NULL;
@@ skipping 134 matching lines @@
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), omnibox, NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   tab_count++;
   EXPECT_EQ(tab_count, browser()->tab_strip_model()->count());
   EXPECT_EQ(host_count, RenderProcessHostCount());
 }
 
 // We don't change process priorities on Mac or Posix because the user lacks the
 // permission to raise a process' priority even after lowering it.
-// TODO(dalecurtis): Reenable this on Windows after figuring out how to reliably
-// wait for the renderer process to process IPC messages.
-#if defined(OS_LINUX)
+#if defined(OS_WIN) || defined(OS_LINUX)
 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest, Backgrounding) {
   if (!base::Process::CanBackgroundProcesses()) {
     LOG(ERROR) << "Can't background processes";
     return;
   }
   CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   parsed_command_line.AppendSwitch(switches::kProcessPerTab);
 
   // Change the first tab to be the omnibox page (TYPE_WEBUI).
   GURL omnibox(chrome::kChromeUIOmniboxURL);
@@ skipping 203 matching lines @@
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::NotificationService::AllSources());
 
   // Kill the renderer process, simulating a crash. This should the ProcessDied
   // method to be called. Alternatively, RenderProcessHost::OnChannelError can
   // be called to directly force a call to ProcessDied.
   base::KillProcess(wc1->GetRenderProcessHost()->GetHandle(), -1, true);
 
   observer.Wait();
 }