When we switch tabs in chrome, the tab being switched away from gets hidden/shown/hidden.

ui/views/controls/native/native_view_host_aura_unittest.cc

 // Copyright (c) 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 "ui/views/controls/native/native_view_host_aura.h"
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
@@ skipping 37 matching lines @@
 
   struct EventDetails {
     EventType type;
     aura::Window* window;
     gfx::Rect bounds;
     bool operator!=(const EventDetails& rhs) {
       return type != rhs.type || window != rhs.window || bounds != rhs.bounds;
     }
   };
 
-  NativeViewHostWindowObserver() {}
+  NativeViewHostWindowObserver()
+    : visibility_state_after_reparenting_(false) {}
+
   virtual ~NativeViewHostWindowObserver() {}
 
   const std::vector<EventDetails>& events() const { return events_; }
 
   // aura::WindowObserver overrides
   virtual void OnWindowVisibilityChanged(aura::Window* window,
                                          bool visible) OVERRIDE {
     EventDetails event;
     event.type = visible ? EVENT_SHOWN : EVENT_HIDDEN;
     event.window = window;
     event.bounds = window->GetBoundsInRootWindow();
 
     // Dedupe events as a single Hide() call can result in several
     // notifications.
     if (events_.size() == 0u || events_.back() != event)
       events_.push_back(event);
   }
 
   virtual void OnWindowBoundsChanged(aura::Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& new_bounds) OVERRIDE {
     EventDetails event;
     event.type = EVENT_BOUNDS_CHANGED;
     event.window = window;
     event.bounds = window->GetBoundsInRootWindow();
     events_.push_back(event);
   }
 
+  virtual void OnWindowParentChanged(aura::Window* window,

[sky, 2014/09/11 14:55:05]

Can't you at events_, since presumably OnWindowVisibilityChanged is being
called, right?

[ananta, 2014/09/11 15:01:56]

OnWindowVisibilityChanged is only called in Chrome. The WCVA class handles
parent changed and makes the child visible again.

[sky, 2014/09/11 15:29:20]

OnWindowVisibilityChanged is from aura::WindowObserver. It should be invoked any
time the visibility changes, right?

+                                     aura::Window* parent) OVERRIDE {
+    if (parent && !visibility_state_after_reparenting_)
+      visibility_state_after_reparenting_ = window->IsVisible();
+  }
+
+  int visibility_state_after_reparenting() const {
+    return visibility_state_after_reparenting_;
+  }
+
  private:
   std::vector<EventDetails> events_;
   gfx::Rect bounds_at_visibility_changed_;
 
+  // Tracks the visibility state of the window after it was reparented.
+  // changed.
+  int visibility_state_after_reparenting_;
+
   DISALLOW_COPY_AND_ASSIGN(NativeViewHostWindowObserver);
 };
 
 class NativeViewHostAuraTest : public ViewsTestBase {
  public:
   NativeViewHostAuraTest() {
   }
 
   NativeViewHostAura* native_host() {
     return static_cast<NativeViewHostAura*>(host_->native_wrapper_.get());
@@ skipping 216 matching lines @@
 
   NativeViewHostWindowObserver test_observer;
   clipping_window()->AddObserver(&test_observer);
   child()->GetNativeView()->AddObserver(&test_observer);
 
   host()->Detach();
 
   ASSERT_EQ(3u, test_observer.events().size());
   EXPECT_EQ(NativeViewHostWindowObserver::EVENT_HIDDEN,
             test_observer.events()[0].type);
-  EXPECT_EQ(clipping_window(), test_observer.events()[0].window);
+  EXPECT_EQ(child()->GetNativeView(), test_observer.events()[0].window);
+  EXPECT_EQ(NativeViewHostWindowObserver::EVENT_HIDDEN,
+            test_observer.events()[1].type);
+  EXPECT_EQ(clipping_window(), test_observer.events()[1].window);
   EXPECT_EQ(NativeViewHostWindowObserver::EVENT_BOUNDS_CHANGED,
-            test_observer.events()[1].type);
-  EXPECT_EQ(child()->GetNativeView(), test_observer.events()[1].window);
-  EXPECT_EQ(NativeViewHostWindowObserver::EVENT_HIDDEN,
             test_observer.events()[2].type);
   EXPECT_EQ(child()->GetNativeView(), test_observer.events()[2].window);
 
   clipping_window()->RemoveObserver(&test_observer);
   child()->GetNativeView()->RemoveObserver(&test_observer);
 
   DestroyHost();
 }
 
 // Ensure the native view receives the correct bounds notification when it is
@@ skipping 45 matching lines @@
   EXPECT_TRUE(child()->IsVisible());
 
   host()->SetVisible(false);
   EXPECT_FALSE(clipping_window()->IsVisible());
   EXPECT_FALSE(child()->IsVisible());
 
   DestroyHost();
   DestroyTopLevel();
 }
 
+// This test validates that detaching the host after it has become visible with
+// valid bounds, hides the host native view before it is reparented.
+TEST_F(NativeViewHostAuraTest, DetachHidesNativeViewBeforeReparenting) {
+  CreateHost();
+
+  toplevel()->SetBounds(gfx::Rect(20, 20, 100, 100));
+  toplevel()->Show();
+
+  host()->SetBounds(10, 10, 80, 80);
+  EXPECT_TRUE(clipping_window()->IsVisible());
+  EXPECT_TRUE(child()->IsVisible());
+
+  NativeViewHostWindowObserver test_observer;
+  host()->native_view()->AddObserver(&test_observer);
+
+  // Save away the native view in a local as it is null'ed out in the Detach
+  // call.
+  aura::Window* native_view = host()->native_view();
+  host()->Detach();
+
+  EXPECT_FALSE(clipping_window()->IsVisible());
+  EXPECT_FALSE(child()->IsVisible());
+
+  EXPECT_FALSE(test_observer.visibility_state_after_reparenting());
+  native_view->RemoveObserver(&test_observer);
+  DestroyHost();
+  DestroyTopLevel();
+}
+
 }  // namespace views