Mac: Make calling WebContents::WasShown/WasHidden the responsibility of the content layer

ui/views/controls/webview/webview_unittest.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 "ui/views/controls/webview/webview.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/web_contents_tester.h"
 #include "content/test/test_content_browser_client.h"
-#include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/views/controls/native/native_view_host.h"
 #include "ui/views/test/test_views_delegate.h"
 #include "ui/views/test/widget_test.h"
 
+#if defined(USE_AURA)
+#include "ui/aura/window.h"
+#endif
+
 namespace views {
 
 namespace {
 
 // Provides functionality to create a test WebContents.
 class WebViewTestViewsDelegate : public views::TestViewsDelegate {
  public:
   WebViewTestViewsDelegate() {}
   ~WebViewTestViewsDelegate() override {}
 
   // Overriden from TestViewsDelegate.
   content::WebContents* CreateWebContents(
       content::BrowserContext* browser_context,
       content::SiteInstance* site_instance) override {
     return content::WebContentsTester::CreateTestWebContents(browser_context,
                                                              site_instance);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebViewTestViewsDelegate);
 };
 
-// Provides functionaity to observe events on a WebContents like WasShown/
+// Provides functionality to observe events on a WebContents like WasShown/
 // WasHidden/WebContentsDestroyed.
 class WebViewTestWebContentsObserver : public content::WebContentsObserver {
  public:
   WebViewTestWebContentsObserver(content::WebContents* web_contents)
       : web_contents_(web_contents),
         was_shown_(false),
         shown_count_(0),
-        hidden_count_(0) {
+        hidden_count_(0),
+        valid_root_while_shown_(true) {
     content::WebContentsObserver::Observe(web_contents);
   }
 
   ~WebViewTestWebContentsObserver() override {
     if (web_contents_)
       content::WebContentsObserver::Observe(NULL);
   }
 
   void WebContentsDestroyed() override {
     DCHECK(web_contents_);
     content::WebContentsObserver::Observe(NULL);
     web_contents_ = NULL;
   }
 
   void WasShown() override {
+#if defined(USE_AURA)
     valid_root_while_shown_ =
         web_contents()->GetNativeView()->GetRootWindow() != NULL;
+#endif
     was_shown_ = true;
     ++shown_count_;
   }
 
   void WasHidden() override {
     was_shown_ = false;
     ++hidden_count_;
   }
 
   bool was_shown() const { return was_shown_; }
@@ skipping 108 matching lines @@
 // WebContents visible and hidden respectively.
 TEST_F(WebViewUnitTest, TestWebViewAttachDetachWebContents) {
   // Case 1: Create a new WebContents and set it in the webview via
   // SetWebContents. This should make the WebContents visible.
   const scoped_ptr<content::WebContents> web_contents1(CreateWebContents());
   WebViewTestWebContentsObserver observer1(web_contents1.get());
   EXPECT_FALSE(observer1.was_shown());
 
   web_view()->SetWebContents(web_contents1.get());
   EXPECT_TRUE(observer1.was_shown());
+#if defined(USE_AURA)
   EXPECT_TRUE(web_contents1->GetNativeView()->IsVisible());
+#endif
   EXPECT_EQ(observer1.shown_count(), 1);
   EXPECT_EQ(observer1.hidden_count(), 0);
   EXPECT_TRUE(observer1.valid_root_while_shown());
 
   // Case 2: Create another WebContents and replace the current WebContents
   // via SetWebContents(). This should hide the current WebContents and show
   // the new one.
   const scoped_ptr<content::WebContents> web_contents2(CreateWebContents());
   WebViewTestWebContentsObserver observer2(web_contents2.get());
   EXPECT_FALSE(observer2.was_shown());
@@ skipping 17 matching lines @@
 
   EXPECT_EQ(1, observer1.shown_count());
   web_view()->SetWebContents(web_contents1.get());
   EXPECT_EQ(1, observer1.shown_count());
 
   // Nothing else should change.
   EXPECT_EQ(1, observer1.hidden_count());
   EXPECT_EQ(1, observer2.shown_count());
   EXPECT_EQ(1, observer2.hidden_count());
 
+#if defined(USE_AURA)
   // Case 4: Test that making the webview visible when a window has an invisible
   // parent does not make the web contents visible.
   top_level_widget()->Hide();
   web_view()->SetVisible(true);
   // TODO(tapted): The following line is wrong, the shown_count() should still
   // be 1, until the parent window is made visible on the line after.
   EXPECT_EQ(2, observer1.shown_count());
   top_level_widget()->Show();
   EXPECT_EQ(2, observer1.shown_count());
   top_level_widget()->Hide();
   EXPECT_EQ(2, observer1.hidden_count());
-
+#else
+  // On Mac, changes to window visibility do not trigger calls to WebContents::
+  // WasShown() or WasHidden(), since the OS does not provide good signals for
+  // window visibility. However, we can still test that moving a visible WebView
+  // whose WebContents is not currently showing to a new, visible window will
+  // show the WebContents. Simulate the "hide window with visible WebView" step
+  // simply by detaching the WebContents.
+  web_view()->SetVisible(true);
+  EXPECT_EQ(2, observer1.shown_count());
+  web_view()->holder()->Detach();
+  EXPECT_EQ(2, observer1.hidden_count());
+#endif
   // Case 5: Test that moving from a hidden parent to a visible parent makes the
   // web contents visible.
   Widget* parent2 = CreateTopLevelFramelessPlatformWidget();
   parent2->SetBounds(gfx::Rect(0, 10, 100, 100));
   parent2->Show();
   EXPECT_EQ(2, observer1.shown_count());
   // Note: that reparenting the windows directly, after the windows have been
   // created, e.g., Widget::ReparentNativeView(widget, parent2), is not a
   // supported use case. Instead, move the WebView over.
   parent2->SetContentsView(web_view());
@@ skipping 171 matching lines @@
       gfx::Point(),  // Immaterial.
       ui::EventTimeForNow(), ui::EF_LEFT_MOUSE_BUTTON, 0);
   EXPECT_FALSE(static_cast<views::View*>(web_view())->
                   OnMousePressed(click_inside_holder));
   EXPECT_FALSE(web_view()->HasFocus());
   EXPECT_FALSE(holder()->HasFocus());
   EXPECT_TRUE(something_to_focus->HasFocus());
 }
 
 }  // namespace views