Plugin Power Saver: Implement pixel tests for plugin placeholders.

chrome/browser/ui/exclusive_access/flash_fullscreen_interactive_browsertest.cc

 // Copyright 2014 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/exclusive_access/fullscreen_controller.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "chrome/test/ppapi/ppapi_test.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/test_utils.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace {
 
 #if defined(OS_MACOSX)
 const bool kIsMacUI = true;
 #else
 const bool kIsMacUI = false;
 #endif
 
-// Runs the current MessageLoop until |condition| is true or timeout.
-bool RunLoopUntil(const base::Callback<bool()>& condition) {
-  const base::TimeTicks start_time = base::TimeTicks::Now();
-  while (!condition.Run()) {
-    const base::TimeTicks current_time = base::TimeTicks::Now();
-    if (current_time - start_time > base::TimeDelta::FromSeconds(10)) {
-      ADD_FAILURE() << "Condition not met within ten seconds.";
-      return false;
-    }
-
-    base::MessageLoop::current()->task_runner()->PostDelayedTask(
-        FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
-        base::TimeDelta::FromMilliseconds(20));
-    content::RunMessageLoop();
-  }
-  return true;
-}
-
 }  // namespace
 
 // A BrowserTest that opens a test page that launches a simulated fullscreen
 // Flash plugin.  The plugin responds to mouse clicks and key presses by
 // changing color.  Once launched, the browser UI can be tested to confirm the
 // desired interactive behaviors.
 class FlashFullscreenInteractiveBrowserTest : public OutOfProcessPPAPITest {
  public:
   FlashFullscreenInteractiveBrowserTest() {}
   ~FlashFullscreenInteractiveBrowserTest() override {}
@@ skipping 24 matching lines @@
 
     EXPECT_TRUE(ObserveTabIsInFullscreen(true));
 
     return !::testing::Test::HasFailure();
   }
 
   void UseAcceleratorToOpenNewTab() {
     content::WebContents* const old_tab_contents = GetActiveWebContents();
     EXPECT_TRUE(ui_test_utils::SendKeyPressSync(
         browser(), ui::VKEY_T, !kIsMacUI, false, false, kIsMacUI));
-    EXPECT_TRUE(RunLoopUntil(base::Bind(
+    EXPECT_TRUE(ui_test_utils::RunLoopUntil(base::Bind(
         &FlashFullscreenInteractiveBrowserTest::IsObservingActiveWebContents,
-        base::Unretained(this),
-        old_tab_contents,
-        false)));
+        base::Unretained(this), old_tab_contents, false)));
   }
 
   void UseAcceleratorToSwitchToTab(int tab_index) {
     content::WebContents* const old_tab_contents = GetActiveWebContents();
     const ui::KeyboardCode key_code =
         static_cast<ui::KeyboardCode>(ui::VKEY_1 + tab_index);
     EXPECT_TRUE(ui_test_utils::SendKeyPressSync(
         browser(), key_code, !kIsMacUI, false, false, kIsMacUI));
-    EXPECT_TRUE(RunLoopUntil(base::Bind(
+    EXPECT_TRUE(ui_test_utils::RunLoopUntil(base::Bind(
         &FlashFullscreenInteractiveBrowserTest::IsObservingActiveWebContents,
-        base::Unretained(this),
-        old_tab_contents,
-        false)));
+        base::Unretained(this), old_tab_contents, false)));
   }
 
   void PressEscape() {
     EXPECT_TRUE(ui_test_utils::SendKeyPressSync(
         browser(), ui::VKEY_ESCAPE, false, false, false, false));
   }
 
   void PressSpacebar() {
     EXPECT_TRUE(ui_test_utils::SendKeyPressSync(
         browser(), ui::VKEY_SPACE, false, false, false, false));
   }
 
   void SpamSpacebar() {
     for (int i = 0; i < 11; ++i)
       PressSpacebar();
   }
 
   void ClickOnTabContainer() {
     ui_test_utils::ClickOnView(browser(), VIEW_ID_TAB_CONTAINER);
   }
 
   void ClickOnOmnibox() {
     ui_test_utils::ClickOnView(browser(), VIEW_ID_OMNIBOX);
   }
 
   bool ObserveTabIsInFullscreen(bool expected_in_fullscreen) const {
-    if (!RunLoopUntil(base::Bind(
+    if (!ui_test_utils::RunLoopUntil(base::Bind(
             &FlashFullscreenInteractiveBrowserTest::IsObservingTabInFullscreen,
-            base::Unretained(this),
-            GetActiveWebContents(),
+            base::Unretained(this), GetActiveWebContents(),
             expected_in_fullscreen)))
       return false;
 
     if (expected_in_fullscreen) {
       if (!GetActiveWebContents()->GetFullscreenRenderWidgetHostView()) {
         ADD_FAILURE()
             << "WebContents should have a fullscreen RenderWidgetHostView.";
         return false;
       }
       EXPECT_EQ(GetActiveWebContents()->GetCapturerCount() > 0,
                 !browser()
                      ->exclusive_access_manager()
                      ->fullscreen_controller()
                      ->IsWindowFullscreenForTabOrPending());
     }
 
     return true;
   }
 
   bool ObserveFlashHasFocus(content::WebContents* contents,
                             bool expected_to_have_focus) const {
-    if (!RunLoopUntil(base::Bind(
+    if (!ui_test_utils::RunLoopUntil(base::Bind(
             &FlashFullscreenInteractiveBrowserTest::IsObservingFlashHasFocus,
-            base::Unretained(this),
-            contents,
-            expected_to_have_focus)))
+            base::Unretained(this), contents, expected_to_have_focus)))
       return false;
 
     if (expected_to_have_focus) {
       content::RenderWidgetHostView* const web_page_view =
           contents->GetRenderWidgetHostView();
       EXPECT_FALSE(web_page_view && web_page_view->HasFocus())
           << "Both RenderWidgetHostViews cannot have focus at the same time.";
 
       if (contents == GetActiveWebContents())
         EXPECT_TRUE(ui_test_utils::IsViewFocused(browser(),
                                                  VIEW_ID_TAB_CONTAINER));
     }
 
     return true;
   }
 
   bool ObserveFlashFillColor(SkColor expected_color) const {
-    return RunLoopUntil(base::Bind(
+    return ui_test_utils::RunLoopUntil(base::Bind(
         &FlashFullscreenInteractiveBrowserTest::IsObservingFlashFillColor,
-        base::Unretained(this),
-        expected_color));
+        base::Unretained(this), expected_color));
   }
 
  private:
   bool IsObservingTabInFullscreen(content::WebContents* contents,
                                   bool expected_in_fullscreen) const {
     return expected_in_fullscreen ==
            browser()
                ->exclusive_access_manager()
                ->fullscreen_controller()
                ->IsFullscreenForTabOrPending(contents);
@@ skipping 147 matching lines @@
   ASSERT_TRUE(ObserveFlashFillColor(SK_ColorRED));
   PressSpacebar();
   ASSERT_TRUE(ObserveFlashFillColor(SK_ColorBLUE));
 
   // Test that the Escape key is handled as an exit fullscreen command while the
   // Flash widget has the focus.
   EXPECT_TRUE(ObserveFlashHasFocus(first_tab_contents, true));
   PressEscape();
   EXPECT_TRUE(ObserveTabIsInFullscreen(false));
 }