Allow backgrounding processes on Mac

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 "base/macros.h"
 #include "base/path_service.h"
 #include "base/process/process.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 14 matching lines @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_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/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "net/base/filename_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 
+#if defined(OS_MACOSX)
+#include "content/public/browser/browser_child_process_host.h"
+#endif  // defined(OS_MACOSX)
+
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 namespace {
 
 int RenderProcessHostCount() {
   content::RenderProcessHost::iterator hosts =
       content::RenderProcessHost::AllHostsIterator();
   int count = 0;
@@ skipping 244 matching lines @@
   // Create another omnibox tab.  It should share the process with the other
   // WebUI.
   ui_test_utils::NavigateToURLWithDisposition(
       browser(), omnibox, WindowOpenDisposition::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
+// We don't change process priorities on Posix because the user lacks the
 // permission to raise a process' priority even after lowering it.
-#if defined(OS_WIN) || defined(OS_LINUX)
+#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostTest, Backgrounding) {
   if (!base::Process::CanBackgroundProcesses()) {
     LOG(ERROR) << "Can't background processes";
     return;
   }
+#if defined(OS_MACOSX)
+  base::PortProvider* port_provider =
+      content::BrowserChildProcessHost::GetPortProvider();
+#endif  //  defined(OS_MACOSX)
+
   base::CommandLine& parsed_command_line =
       *base::CommandLine::ForCurrentProcess();
   parsed_command_line.AppendSwitch(switches::kProcessPerTab);
 
   // Change the first tab to be the omnibox page (TYPE_WEBUI).
   GURL omnibox(chrome::kChromeUIOmniboxURL);
   ui_test_utils::NavigateToURL(browser(), omnibox);
 
   // Create a new tab. It should be foreground.
   GURL page1("data:text/html,hello world1");
   base::Process process1 = ShowSingletonTab(page1);
   ASSERT_TRUE(process1.IsValid());
+#if defined(OS_MACOSX)
+  EXPECT_FALSE(process1.IsProcessBackgrounded(port_provider));
+#else
   EXPECT_FALSE(process1.IsProcessBackgrounded());
+#endif
 
   // Create another tab. It should be foreground, and the first tab should
   // now be background.
   GURL page2("data:text/html,hello world2");
   base::Process process2 = ShowSingletonTab(page2);
   ASSERT_TRUE(process2.IsValid());
   EXPECT_NE(process1.Pid(), process2.Pid());
+#if defined(OS_MACOSX)
+  EXPECT_TRUE(process1.IsProcessBackgrounded(port_provider));
+  EXPECT_FALSE(process2.IsProcessBackgrounded(port_provider));
+#else
   EXPECT_TRUE(process1.IsProcessBackgrounded());
   EXPECT_FALSE(process2.IsProcessBackgrounded());
+#endif  // defined(OS_MACOSX)
 
   // Load another tab in background. The renderer of the new tab should be
   // backgrounded, while visibility of the other renderers should not change.
   GURL page3("data:text/html,hello world3");
   base::Process process3 = OpenBackgroundTab(page3);
   ASSERT_TRUE(process3.IsValid());
   EXPECT_NE(process3.Pid(), process1.Pid());
   EXPECT_NE(process3.Pid(), process2.Pid());
+#if defined(OS_MACOSX)
+  EXPECT_TRUE(process1.IsProcessBackgrounded(port_provider));
+  EXPECT_FALSE(process2.IsProcessBackgrounded(port_provider));
+  // TODO(gab): The new background tab should be backgrounded but it currently
+  // intentionally isn't per a workaround to https://crbug.com/560446 in
+  // RenderProcessHostImpl::OnProcessLaunched().
+  EXPECT_FALSE(process3.IsProcessBackgrounded(port_provider));
+
+  // Navigate back to the first page. Its renderer should be in foreground
+  // again while the other renderers should be backgrounded.
+
+  EXPECT_EQ(process1.Pid(), ShowSingletonTab(page1).Pid());
+  EXPECT_FALSE(process1.IsProcessBackgrounded(port_provider));
+  EXPECT_TRUE(process2.IsProcessBackgrounded(port_provider));
+  // TODO(gab): Same as above.
+  EXPECT_FALSE(process3.IsProcessBackgrounded(port_provider));
+
+  // TODO(gab): Remove this when https://crbug.com/560446 is fixed, but for now
+  // confirm that the correct state is at least achieved when tab #3 is
+  // explicitly foregrounded and re-backgrounded.
+  EXPECT_EQ(process3.Pid(), ShowSingletonTab(page3).Pid());
+  EXPECT_EQ(process1.Pid(), ShowSingletonTab(page1).Pid());
+  EXPECT_FALSE(process1.IsProcessBackgrounded(port_provider));
+  EXPECT_TRUE(process2.IsProcessBackgrounded(port_provider));
+  EXPECT_TRUE(process3.IsProcessBackgrounded(port_provider));
+#else
   EXPECT_TRUE(process1.IsProcessBackgrounded());
   EXPECT_FALSE(process2.IsProcessBackgrounded());
   // TODO(gab): The new background tab should be backgrounded but it currently
   // intentionally isn't per a workaround to https://crbug.com/560446 in
   // RenderProcessHostImpl::OnProcessLaunched().
   EXPECT_FALSE(process3.IsProcessBackgrounded());
 
   // Navigate back to the first page. Its renderer should be in foreground
   // again while the other renderers should be backgrounded.
+
   EXPECT_EQ(process1.Pid(), ShowSingletonTab(page1).Pid());
   EXPECT_FALSE(process1.IsProcessBackgrounded());
   EXPECT_TRUE(process2.IsProcessBackgrounded());
   // TODO(gab): Same as above.
   EXPECT_FALSE(process3.IsProcessBackgrounded());
 
   // TODO(gab): Remove this when https://crbug.com/560446 is fixed, but for now
   // confirm that the correct state is at least achieved when tab #3 is
   // explicitly foregrounded and re-backgrounded.
   EXPECT_EQ(process3.Pid(), ShowSingletonTab(page3).Pid());
   EXPECT_EQ(process1.Pid(), ShowSingletonTab(page1).Pid());
   EXPECT_FALSE(process1.IsProcessBackgrounded());
   EXPECT_TRUE(process2.IsProcessBackgrounded());
   EXPECT_TRUE(process3.IsProcessBackgrounded());
+#endif
 }
 #endif
 
 // TODO(nasko): crbug.com/173137
 // Disable on Windows and Mac due to ongoing flakiness. (crbug.com/442785)
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #define MAYBE_ProcessOverflow DISABLED_ProcessOverflow
 #else
 #define MAYBE_ProcessOverflow ProcessOverflow
 #endif
@@ skipping 199 matching lines @@
         browser()->tab_strip_model()->GetActiveWebContents();
 
     // Create a new tab for the no audio page and confirm that the process of
     // each tab is different and that both are valid.
     audio_process_ = ProcessFromHandle(
         audio_tab_web_contents_->GetRenderProcessHost()->GetHandle());
     no_audio_process_ = ShowSingletonTab(no_audio_url_);
     ASSERT_NE(audio_process_.Pid(), no_audio_process_.Pid());
     ASSERT_TRUE(no_audio_process_.IsValid());
     ASSERT_TRUE(audio_process_.IsValid());
+#if defined(OS_MACOSX)
+    port_provider_ = content::BrowserChildProcessHost::GetPortProvider();
+#endif //  defined(OS_MACOSX)
   }
 
  protected:
+  void WaitUntilBackgrounded(const base::Process& lhs,
+                             bool lhs_backgrounded,
+                             const base::Process& rhs,
+                             bool rhs_backgrounded) {
+    while (IsProcessBackgrounded(lhs) != lhs_backgrounded ||
+           IsProcessBackgrounded(rhs) != rhs_backgrounded) {
+      base::RunLoop().RunUntilIdle();
+      base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+    }
+  }
+
   GURL audio_url_;
   GURL no_audio_url_;
 
   base::Process audio_process_;
   base::Process no_audio_process_;
 
   content::WebContents* audio_tab_web_contents_;
 
  private:
+  bool IsProcessBackgrounded(const base::Process& process) {
+#if defined(OS_MACOSX)
+    return process.IsProcessBackgrounded(port_provider_);
+#else
+    return process.IsProcessBackgrounded();
+#endif
+  }
+
+#if defined(OS_MACOSX)
+  base::PortProvider* port_provider_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(ChromeRenderProcessHostBackgroundingTest);
 };
 
 // Test to make sure that a process is backgrounded when the audio stops playing
 // from the active tab and there is an immediate tab switch.
 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostBackgroundingTest,
                        ProcessPriorityAfterStoppedAudio) {
   // This test is invalid on platforms that can't background.
   if (!base::Process::CanBackgroundProcesses())
     return;
 
   ShowSingletonTab(audio_url_);
 
   // Wait until the no audio page is backgrounded and the audio page is not
   // backgrounded.
-  while (!no_audio_process_.IsProcessBackgrounded() ||
-         audio_process_.IsProcessBackgrounded()) {
-    base::RunLoop().RunUntilIdle();
-    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-  }
-
+  WaitUntilBackgrounded(no_audio_process_, true, audio_process_, false);
   // Pause the audio and immediately switch to the no audio tab.
   ASSERT_TRUE(content::ExecuteScript(
       audio_tab_web_contents_,
       "document.getElementById('audioPlayer').pause();"));
   ShowSingletonTab(no_audio_url_);
 
   // Wait until the no audio page is not backgrounded and the audio page is
   // backgrounded.
-  while (no_audio_process_.IsProcessBackgrounded() ||
-         !audio_process_.IsProcessBackgrounded()) {
-    base::RunLoop().RunUntilIdle();
-    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-  }
+  WaitUntilBackgrounded(no_audio_process_, false, audio_process_, true);
 }
 
 // Test to make sure that a process is backgrounded automatically when audio
 // stops playing from a hidden tab.
 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostBackgroundingTest,
                        ProcessPriorityAfterAudioStopsOnNotVisibleTab) {
   // This test is invalid on platforms that can't background.
   if (!base::Process::CanBackgroundProcesses())
     return;
 
   // Wait until the two pages are not backgrounded.
-  while (no_audio_process_.IsProcessBackgrounded() ||
-         audio_process_.IsProcessBackgrounded()) {
-    base::RunLoop().RunUntilIdle();
-    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-  }
-
+  WaitUntilBackgrounded(audio_process_, false, no_audio_process_, false);
   // Stop the audio.
   ASSERT_TRUE(content::ExecuteScript(
       audio_tab_web_contents_,
       "document.getElementById('audioPlayer').pause();"));
 
   // Wait until the no audio page is not backgrounded and the audio page is
   // backgrounded.
-  while (no_audio_process_.IsProcessBackgrounded() ||
-         !audio_process_.IsProcessBackgrounded()) {
-    base::RunLoop().RunUntilIdle();
-    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-  }
+  WaitUntilBackgrounded(no_audio_process_, false, audio_process_, true);
 }
 
-// Test to make sure that a process is un-backgrounded automatically when audio
+// Test to make sure that a process is un-backgrounded automatically when
+// audio
 // starts playing from a backgrounded tab.
 IN_PROC_BROWSER_TEST_F(ChromeRenderProcessHostBackgroundingTest,
                        ProcessPriorityAfterAudioStartsFromBackgroundTab) {
   // This test is invalid on platforms that can't background.
   if (!base::Process::CanBackgroundProcesses())
     return;
 
   // Stop the audio.
   ASSERT_TRUE(content::ExecuteScript(
       audio_tab_web_contents_,
       "document.getElementById('audioPlayer').pause();"));
 
-  // Wait until the no audio page is not backgrounded and the audio page is
-  // backgrounded.
-  while (no_audio_process_.IsProcessBackgrounded() ||
-         !audio_process_.IsProcessBackgrounded()) {
-    base::RunLoop().RunUntilIdle();
-    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-  }
+  WaitUntilBackgrounded(no_audio_process_, false, audio_process_, true);
 
   // Start the audio from the backgrounded tab.
   ASSERT_TRUE(
       content::ExecuteScript(audio_tab_web_contents_,
                              "document.getElementById('audioPlayer').play();"));
 
   // Wait until the two pages are not backgrounded.
-  while (no_audio_process_.IsProcessBackgrounded() ||
-         audio_process_.IsProcessBackgrounded()) {
-    base::RunLoop().RunUntilIdle();
-    base::PlatformThread::Sleep(TestTimeouts::tiny_timeout());
-  }
+  WaitUntilBackgrounded(no_audio_process_, false, audio_process_, false);
 }