Make code path for bounds changes getting to renderer less brittle

content/browser/web_contents/aura/native_view_screen_bounds_observer_unittest.cc

Index: content/browser/web_contents/aura/native_view_screen_bounds_observer_unittest.cc
diff --git a/content/browser/web_contents/aura/native_view_screen_bounds_observer_unittest.cc b/content/browser/web_contents/aura/native_view_screen_bounds_observer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..a59e39865b16eae3ad2d52654b78fedcc8615041
--- /dev/null
+++ b/content/browser/web_contents/aura/native_view_screen_bounds_observer_unittest.cc
@@ -0,0 +1,313 @@
+// 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 "content/browser/web_contents/aura/native_view_screen_bounds_observer.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/aura/root_window.h"
+#include "ui/aura/test/aura_test_base.h"
+#include "ui/aura/window.h"
+
+namespace content {
+
+class NativeViewScreenBoundsObserverDelegateStub
+    : public  NativeViewScreenBoundsObserverDelegate {
+ public:
+  NativeViewScreenBoundsObserverDelegateStub() : window_(NULL),
+                                                 position_changed_count_(0),
+                                                 bounds_changed_count_(0) {
+  }
+  virtual ~NativeViewScreenBoundsObserverDelegateStub() { }
+
+  void SetDelegateWindow(aura::Window* window) { window_ = window; }
+
+  void ClearCounts() {
+    position_changed_count_ = 0;
+    bounds_changed_count_ = 0;
+  }
+
+  int GetPositionChangedCount() {
+    return position_changed_count_;
+  }
+
+  int GetBoundsChangedCount() {
+    return bounds_changed_count_;
+  }
+
+  // Overriden from NativeViewScreenBoundsObserverDelegate
+  virtual aura::Window* GetDelegateWindow() OVERRIDE { return window_; }
+  virtual void AddDelegateWindowObserver(aura::WindowObserver* observer)
+      OVERRIDE {}
+  virtual void RemoveDelegateWindowObserver(aura::WindowObserver* observer)
+      OVERRIDE {}
+  virtual void RemoveRootWindowObserver(aura::RootWindowObserver* observer)
+      OVERRIDE {}
+  virtual void AddRootWindowObserver(aura::RootWindowObserver* observer)
+      OVERRIDE {}
+  virtual void OnScreenPositionChanged() OVERRIDE {
+    position_changed_count_++;
+  }
+  virtual void OnScreenBoundsChanged() OVERRIDE {
+    bounds_changed_count_++;
+  }
+
+ private:
+  aura::Window* window_;
+  int position_changed_count_;
+  int bounds_changed_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeViewScreenBoundsObserverDelegateStub);
+};
+
+class NativeViewScreenBoundsObserverTest : public aura::test::AuraTestBase {
+ public:
+  NativeViewScreenBoundsObserverTest() {}
+  virtual ~NativeViewScreenBoundsObserverTest() { }
+
+  virtual void SetUp() {
+    aura::test::AuraTestBase::SetUp();
+    observer_.Init(&delegate_);
+  }
+
+  bool IsWindowInSet(aura::Window* window, std::set<aura::Window*> windows) {
+    return (windows.end() != windows.find(window));
+  }
+
+  bool IsWindowObserved(aura::Window* window) {
+    return IsWindowInSet(window, observed());

[sadrul, 2013/11/08 02:16:26]

Use aura::Window::HasObserver() to determine this

[rharrison, 2013/11/12 22:16:29]

Done.

+  }
+
+  std::set<aura::Window*> observed() { return observer_.observed_; }
+
+  void ClearObserver() {
+    observer_.RemoveFromObserved(observed());
+    delegate_.RemoveRootWindowObserver(&observer_);
+    delegate_.RemoveDelegateWindowObserver(&observer_);
+  }
+
+  std::set<aura::Window*> GenerateAncestors(aura::Window* window) {
+    return observer_.GenerateAncestors(window);
+  }
+
+  void AddToObserved(const std::set<aura::Window*>& windows) {
+    observer_.AddToObserved(windows);
+  }
+
+  void RemoveFromObserved(const std::set<aura::Window*>& windows) {
+    observer_.RemoveFromObserved(windows);
+  }
+
+  NativeViewScreenBoundsObserver observer_;
+  NativeViewScreenBoundsObserverDelegateStub delegate_;
+};
+
+TEST_F(NativeViewScreenBoundsObserverTest, Init) {
+  EXPECT_EQ(static_cast<unsigned int>(0), observed().size());

[sadrul, 2013/11/08 02:16:26]

EXPECT_EQ(0u, observed().size())

[rharrison, 2013/11/12 22:16:29]

Done.

+  ClearObserver();
+
+  // observed count is the number of windows created + 1 due to the root_window
+  // being at the top.
+  aura::Window* delegate_window = CreateNormalWindow(0, root_window(), NULL);
+  delegate_.SetDelegateWindow(delegate_window);
+  observer_.Init(&delegate_);
+  EXPECT_EQ(static_cast<unsigned int>(2), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+  ClearObserver();
+
+  aura::Window* parent_window = CreateNormalWindow(0, root_window(), NULL);
+  parent_window->AddChild(delegate_window);
+  observer_.Init(&delegate_);
+  EXPECT_EQ(static_cast<unsigned int>(3), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+  EXPECT_TRUE(IsWindowObserved(parent_window));
+  ClearObserver();
+
+  aura::Window* grandparent_window = CreateNormalWindow(0, root_window(), NULL);
+  grandparent_window->AddChild(parent_window);
+  observer_.Init(&delegate_);
+  EXPECT_EQ(static_cast<unsigned int>(4), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+  EXPECT_TRUE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+  ClearObserver();
+}
+
+TEST_F(NativeViewScreenBoundsObserverTest, OnWindowParentChanged) {
+  aura::Window* delegate_window = CreateNormalWindow(0, root_window(), NULL);
+  delegate_.SetDelegateWindow(delegate_window);
+  observer_.Init(&delegate_);
+  EXPECT_EQ(static_cast<unsigned int>(2), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+
+  aura::Window* parent_window = CreateNormalWindow(0, root_window(), NULL);
+  parent_window->AddChild(delegate_window);
+  EXPECT_EQ(static_cast<unsigned int>(3), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+  EXPECT_TRUE(IsWindowObserved(parent_window));
+
+  aura::Window* grandparent_window = CreateNormalWindow(0, root_window(), NULL);
+  grandparent_window->AddChild(parent_window);
+  EXPECT_EQ(static_cast<unsigned int>(4), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+  EXPECT_TRUE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+
+  aura::Window* new_parent_window = CreateNormalWindow(0, root_window(), NULL);
+  new_parent_window->AddChild(delegate_window);
+  EXPECT_EQ(static_cast<unsigned int>(3), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+  EXPECT_FALSE(IsWindowObserved(parent_window));
+  EXPECT_FALSE(IsWindowObserved(grandparent_window));
+  EXPECT_TRUE(IsWindowObserved(new_parent_window));
+
+  grandparent_window->AddChild(new_parent_window);
+  EXPECT_EQ(static_cast<unsigned int>(4), observed().size());
+  EXPECT_TRUE(IsWindowObserved(delegate_window));
+  EXPECT_FALSE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+  EXPECT_TRUE(IsWindowObserved(new_parent_window));

[sadrul, 2013/11/08 02:16:26]

Add some expectations on Position/BoundsChangedCount before/after re-parenting,
since that is the primary thing we want to test.

[rharrison, 2013/11/12 22:16:29]

Added additional additional cases in OnWindowBoundsChanged for this.

+}
+
+TEST_F(NativeViewScreenBoundsObserverTest, OnWindowBoundsChanged) {
+  gfx::Rect base_bounds(0, 0, 400, 400);
+  gfx::Rect resized_bounds(0, 0, 200, 200);
+  gfx::Rect moved_bounds(100, 100, 400, 400);
+
+  aura::Window* delegate_window = CreateNormalWindow(0, root_window(), NULL);
+  delegate_window->SetBounds(base_bounds);
+  delegate_.SetDelegateWindow(delegate_window);
+  observer_.Init(&delegate_);
+  delegate_.ClearCounts();
+  delegate_window->SetBounds(resized_bounds);
+  EXPECT_EQ(0, delegate_.GetPositionChangedCount());
+  EXPECT_EQ(1, delegate_.GetBoundsChangedCount());
+
+  delegate_window->SetBounds(base_bounds);
+  delegate_.ClearCounts();
+  delegate_window->SetBounds(moved_bounds);
+  EXPECT_EQ(1, delegate_.GetPositionChangedCount());
+  EXPECT_EQ(0, delegate_.GetBoundsChangedCount());
+
+  aura::Window* parent_window = CreateNormalWindow(0, root_window(), NULL);
+  parent_window->SetBounds(base_bounds);
+  parent_window->AddChild(delegate_window);
+  delegate_.ClearCounts();
+  parent_window->SetBounds(resized_bounds);
+  EXPECT_EQ(0, delegate_.GetPositionChangedCount());
+  EXPECT_EQ(1, delegate_.GetBoundsChangedCount());
+
+  parent_window->SetBounds(base_bounds);
+  delegate_.ClearCounts();
+  parent_window->SetBounds(moved_bounds);
+  EXPECT_EQ(1, delegate_.GetPositionChangedCount());
+  EXPECT_EQ(0, delegate_.GetBoundsChangedCount());
+}
+
+TEST_F(NativeViewScreenBoundsObserverTest, GenerateAncestors) {
+  aura::Window* child_window = CreateNormalWindow(0, root_window(), NULL);
+  std::set<aura::Window*> ancestors;
+  ancestors = GenerateAncestors(child_window);
+  EXPECT_EQ(static_cast<unsigned int>(1), ancestors.size());
+  EXPECT_FALSE(IsWindowInSet(child_window, ancestors));
+
+  aura::Window* parent_window = CreateNormalWindow(0, root_window(), NULL);
+  parent_window->AddChild(child_window);
+  ancestors = GenerateAncestors(child_window);
+  EXPECT_EQ(static_cast<unsigned int>(2), ancestors.size());
+  EXPECT_FALSE(IsWindowInSet(child_window, ancestors));
+  EXPECT_TRUE(IsWindowInSet(parent_window, ancestors));
+
+  aura::Window* grandparent_window = CreateNormalWindow(0, root_window(), NULL);
+  grandparent_window->AddChild(parent_window);
+  ancestors = GenerateAncestors(child_window);
+  EXPECT_EQ(static_cast<unsigned int>(3), ancestors.size());
+  EXPECT_FALSE(IsWindowInSet(child_window, ancestors));
+  EXPECT_TRUE(IsWindowInSet(parent_window, ancestors));
+  EXPECT_TRUE(IsWindowInSet(grandparent_window, ancestors));
+}
+
+TEST_F(NativeViewScreenBoundsObserverTest, AddToObserved) {
+  std::set<aura::Window*> windows;
+  aura::Window* child_window = CreateNormalWindow(0, root_window(), NULL);
+  windows.insert(child_window);
+  AddToObserved(windows);
+  EXPECT_EQ(static_cast<unsigned int>(1), observed().size());
+  EXPECT_TRUE(IsWindowObserved(child_window));
+
+  aura::Window* parent_window = CreateNormalWindow(0, root_window(), NULL);
+  windows.insert(parent_window);
+  AddToObserved(windows);
+  EXPECT_EQ(static_cast<unsigned int>(2), observed().size());
+  EXPECT_TRUE(IsWindowObserved(child_window));
+  EXPECT_TRUE(IsWindowObserved(parent_window));
+
+  aura::Window* grandparent_window = CreateNormalWindow(0, root_window(), NULL);
+  windows.clear();
+  windows.insert(grandparent_window);
+  AddToObserved(windows);
+  EXPECT_EQ(static_cast<unsigned int>(3), observed().size());
+  EXPECT_TRUE(IsWindowObserved(child_window));
+  EXPECT_TRUE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+}
+
+TEST_F(NativeViewScreenBoundsObserverTest, RemoveFromObserved) {

[sadrul, 2013/11/08 02:16:26]

I am not sure what we are testing in these last three tests.

[rharrison, 2013/11/12 22:16:29]

I don't think they are adding more coverage, removing.

+  aura::Window* child_window = CreateNormalWindow(0, root_window(), NULL);
+  aura::Window* parent_window = CreateNormalWindow(0, root_window(), NULL);
+  aura::Window* grandparent_window = CreateNormalWindow(0, root_window(), NULL);
+  std::set<aura::Window*> base_windows;
+  base_windows.insert(child_window);
+  base_windows.insert(parent_window);
+  base_windows.insert(grandparent_window);
+
+  std::set<aura::Window*> removed_windows;
+  AddToObserved(base_windows);
+  RemoveFromObserved(removed_windows);
+  EXPECT_EQ(static_cast<unsigned int>(3), observed().size());
+  EXPECT_TRUE(IsWindowObserved(child_window));
+  EXPECT_TRUE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+
+  removed_windows = base_windows;
+  RemoveFromObserved(removed_windows);
+  EXPECT_EQ(static_cast<unsigned int>(0), observed().size());
+  EXPECT_FALSE(IsWindowObserved(child_window));
+  EXPECT_FALSE(IsWindowObserved(parent_window));
+  EXPECT_FALSE(IsWindowObserved(grandparent_window));
+
+  AddToObserved(base_windows);
+  removed_windows.clear();
+  removed_windows.insert(parent_window);
+  RemoveFromObserved(removed_windows);
+  EXPECT_EQ(static_cast<unsigned int>(2), observed().size());
+  EXPECT_TRUE(IsWindowObserved(child_window));
+  EXPECT_FALSE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+
+  removed_windows.clear();
+  removed_windows.insert(parent_window);
+  RemoveFromObserved(removed_windows);
+  EXPECT_EQ(static_cast<unsigned int>(2), observed().size());
+  EXPECT_TRUE(IsWindowObserved(child_window));
+  EXPECT_FALSE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+
+  removed_windows.clear();
+  removed_windows.insert(child_window);
+  RemoveFromObserved(removed_windows);
+  EXPECT_EQ(static_cast<unsigned int>(1), observed().size());
+  EXPECT_FALSE(IsWindowObserved(child_window));
+  EXPECT_FALSE(IsWindowObserved(parent_window));
+  EXPECT_TRUE(IsWindowObserved(grandparent_window));
+
+  removed_windows.clear();
+  removed_windows.insert(grandparent_window);
+  RemoveFromObserved(removed_windows);
+  EXPECT_EQ(static_cast<unsigned int>(0), observed().size());
+  EXPECT_FALSE(IsWindowObserved(child_window));
+  EXPECT_FALSE(IsWindowObserved(parent_window));
+  EXPECT_FALSE(IsWindowObserved(grandparent_window));
+}
+
+}  // namespace content