Reducing CPU cycles of hidden/minimized browser windows

chrome/browser/ui/views/frame/browser_view_browsertest.cc

 // Copyright 2013 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 "chrome/browser/ui/views/frame/browser_view.h"
 
+#include "base/run_loop.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "ui/base/ui_base_types.h"
 
 typedef InProcessBrowserTest BrowserViewTest;
 
 namespace {
 
 // Used to simulate scenario in a crash. When WebContentsDestroyed() is invoked
 // updates the navigation state of another tab.
 class TestWebContentsObserver : public content::WebContentsObserver {
  public:
   TestWebContentsObserver(content::WebContents* source,
                           content::WebContents* other)
       : content::WebContentsObserver(source),
         other_(other) {}
   virtual ~TestWebContentsObserver() {}
 
   virtual void WebContentsDestroyed() OVERRIDE {
     other_->NotifyNavigationStateChanged(
         content::INVALIDATE_TYPE_URL | content::INVALIDATE_TYPE_LOAD);
   }
 
  private:
   content::WebContents* other_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebContentsObserver);
 };
 
+class WebContentsShowHideObserver : public content::WebContentsObserver {
+ public:
+  WebContentsShowHideObserver(content::WebContents* web_contents,
+                              const base::Closure& callback)
+      : WebContentsObserver(web_contents),
+        callback_(callback),
+        show_state_(ui::SHOW_STATE_DEFAULT) {}
+
+  // WebContentsObserver.
+  virtual void WasHidden() OVERRIDE {
+    show_state_ = ui::SHOW_STATE_INACTIVE;
+    callback_.Run();
+  }
+
+  virtual void WasShown() OVERRIDE {
+    show_state_ = ui::SHOW_STATE_NORMAL;
+    callback_.Run();
+  }
+
+  bool shown() { return show_state_ == ui::SHOW_STATE_NORMAL; }
+  bool hidden() { return show_state_ == ui::SHOW_STATE_INACTIVE; }
+
+ private:
+  base::Closure callback_;
+  ui::WindowShowState show_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebContentsShowHideObserver);
+};
+
 }  // namespace
 
 // Verifies don't crash when CloseNow() is invoked with two tabs in a browser.
 // Additionally when one of the tabs is destroyed NotifyNavigationStateChanged()
 // is invoked on the other.
 IN_PROC_BROWSER_TEST_F(BrowserViewTest, CloseWithTabs) {
   Browser* browser2 =
       new Browser(Browser::CreateParams(browser()->profile(),
                                         browser()->host_desktop_type()));
   chrome::AddTabAt(browser2, GURL(), -1, true);
@@ skipping 11 matching lines @@
       new Browser(Browser::CreateParams(browser()->profile(),
                                         browser()->host_desktop_type()));
   chrome::AddTabAt(browser2, GURL(), -1, true);
   chrome::AddTabAt(browser2, GURL(), -1, true);
   browser2->tab_strip_model()->ActivateTabAt(0, true);
   TestWebContentsObserver observer(
       browser2->tab_strip_model()->GetWebContentsAt(0),
       browser2->tab_strip_model()->GetWebContentsAt(1));
   BrowserView::GetBrowserViewForBrowser(browser2)->GetWidget()->CloseNow();
 }
+
+// Test that hiding a window by minimization will cause the web content to be
+// hidden as well (to save CPU cycles for rendering).
+IN_PROC_BROWSER_TEST_F(BrowserViewTest, MinimizeHidesWebContents) {

[sky, 2014/05/20 19:46:27]

Test coverage should be in content. The test here should be is visibility set to
false on minimize? I'm pretty sure we already have coverage of that in the aura
side.

[Mr4D (OOO till 08-26), 2014/05/20 21:26:56]

I prefer 1:1 tests and not tests which imply that something else is in place
which completes the test. If something later on changes, the proposed test will
return passed but the real thing we want to test does still not work. Anyways.
Done.

[ncarter (slow), 2014/05/20 21:40:01]

Fwiw, I think this test can move to a content_browsertest and provide equivalent
coverage. When I wrote it, I couldn't figure out how to minimize a window from a
content_browsertest, but it looks like shell()->widget()->Minimize() should do
the trick, and I think it'll still substantially exercise the same views
codepath. Inside of content there's the advantage that you can get the
WebContentsImpl and query other things besides.

Since this test would fail without the rest of the patch, it seems that whatever
the current coverage is, it's not sufficient?

+  // Minimizing the window should cause the active WebContents to be hidden.
+  {
+    base::RunLoop run_loop;
+    WebContentsShowHideObserver observed(
+        browser()->tab_strip_model()->GetActiveWebContents(),
+        run_loop.QuitClosure());
+
+    ASSERT_FALSE(observed.hidden());
+    ASSERT_FALSE(observed.shown());
+    browser()->window()->Minimize();
+    if (!observed.hidden())
+      run_loop.RunUntilIdle();
+    ASSERT_TRUE(observed.hidden());
+    ASSERT_FALSE(observed.shown());
+  }
+
+  // Restoring the window should cause the active WebContents to be shown.
+  {
+    base::RunLoop run_loop;
+    WebContentsShowHideObserver observed(
+        browser()->tab_strip_model()->GetActiveWebContents(),
+        run_loop.QuitClosure());
+
+    ASSERT_FALSE(observed.hidden());
+    ASSERT_FALSE(observed.shown());
+    browser()->window()->Restore();
+    if (!observed.shown())
+      run_loop.RunUntilIdle();
+    ASSERT_TRUE(observed.shown());
+    ASSERT_FALSE(observed.hidden());
+  }
+}