Propagate window transformed notification to child hierarchy

ui/aura/window_unittest.cc

 // Copyright (c) 2012 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/aura/window.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 1689 matching lines @@
   }
 
   // Return a tuple of the arguments passed in OnPropertyChanged callback.
   PropertyChangeInfo PropertyChangeInfoAndClear() {
     PropertyChangeInfo result(property_key_, old_property_value_);
     property_key_ = NULL;
     old_property_value_ = -3;
     return result;
   }
 
+  std::string TransformNotificationsAndClear() {
+    std::string result;
+    for (std::vector<std::pair<int, int> >::iterator it =
+            transform_notifications_.begin();
+        it != transform_notifications_.end();
+        ++it) {
+      base::StringAppendF(&result, "(%d,%d)", it->first, it->second);
+    }
+    transform_notifications_.clear();
+    return result;
+  }
+
  private:
   virtual void OnWindowAdded(Window* new_window) OVERRIDE {
     added_count_++;
   }
 
   virtual void OnWillRemoveWindow(Window* window) OVERRIDE {
     removed_count_++;
   }
 
   virtual void OnWindowVisibilityChanged(Window* window,
                                          bool visible) OVERRIDE {
     visibility_info_.reset(new VisibilityInfo);
     visibility_info_->window_visible = window->IsVisible();
     visibility_info_->visible_param = visible;
   }
 
   virtual void OnWindowDestroyed(Window* window) OVERRIDE {
     EXPECT_FALSE(window->parent());
     destroyed_count_++;
   }
 
   virtual void OnWindowPropertyChanged(Window* window,
                                        const void* key,
                                        intptr_t old) OVERRIDE {
     property_key_ = key;
     old_property_value_ = old;
   }
 
+  virtual void OnAncestorWindowTransformed(Window* source,
+                                           Window* window) OVERRIDE {
+    transform_notifications_.push_back(
+        std::make_pair(source->id(), window->id()));
+  }
+
   int added_count_;
   int removed_count_;
   int destroyed_count_;
   scoped_ptr<VisibilityInfo> visibility_info_;
   const void* property_key_;
   intptr_t old_property_value_;
+  std::vector<std::pair<int, int> > transform_notifications_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowObserverTest);
 };
 
 // Various assertions for WindowObserver.
 TEST_F(WindowObserverTest, WindowObserver) {
   scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
   w1->AddObserver(this);
 
   // Create a new window as a child of w1, our observer should be notified.
@@ skipping 96 matching lines @@
   w1->SetNativeWindowProperty(native_prop_key, NULL);
   EXPECT_EQ(PropertyChangeInfo(native_prop_key,
                                reinterpret_cast<intptr_t>(&*w1)),
             PropertyChangeInfoAndClear());
 
   // Sanity check to see if |PropertyChangeInfoAndClear| really clears.
   EXPECT_EQ(PropertyChangeInfo(
       reinterpret_cast<const void*>(NULL), -3), PropertyChangeInfoAndClear());
 }
 
+TEST_F(WindowObserverTest, AncestorTransformed) {
+  // Create following window hierarchy:
+  //   root_window
+  //   +-- w1
+  //       +-- w2
+  //       +-- w3
+  //           +-- w4
+  // Then, apply a transform to |w1| and ensure all its descendants are
+  // notified.
+  scoped_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
+  w1->AddObserver(this);
+  scoped_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
+  w2->AddObserver(this);
+  scoped_ptr<Window> w3(CreateTestWindowWithId(3, w1.get()));
+  w3->AddObserver(this);
+  scoped_ptr<Window> w4(CreateTestWindowWithId(4, w3.get()));
+  w4->AddObserver(this);
+
+  EXPECT_EQ("", TransformNotificationsAndClear());

[sky, 2014/09/10 16:10:47]

nit: either "" -> std::string() or
EXPECT_TRUE(TransformNotificationsAndClear().empty())

+
+  gfx::Transform transform;
+  transform.Translate(10, 10);
+  w1->SetTransform(transform);
+
+  EXPECT_EQ("(1,1)(1,2)(1,3)(1,4)", TransformNotificationsAndClear());
+}
+
 TEST_F(WindowTest, AcquireLayer) {
   scoped_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
   scoped_ptr<Window> window2(CreateTestWindowWithId(2, root_window()));
   ui::Layer* parent = window1->parent()->layer();
   EXPECT_EQ(2U, parent->children().size());
 
   WindowTestApi window1_test_api(window1.get());
   WindowTestApi window2_test_api(window2.get());
 
   EXPECT_TRUE(window1_test_api.OwnsLayer());
@@ skipping 1558 matching lines @@
 
   EXPECT_TRUE(animator.get());
   EXPECT_FALSE(animator->is_animating());
   EXPECT_TRUE(observer.animation_completed());
   EXPECT_FALSE(observer.animation_aborted());
   animator->RemoveObserver(&observer);
 }
 
 }  // namespace test
 }  // namespace aura