aura: Remove NotifyAncestorWindowTransformed in window observer.

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 <limits.h>
 
 #include <string>
 #include <utility>
@@ skipping 1753 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:
   void OnWindowAdded(Window* new_window) override { added_count_++; }
 
   void OnWillRemoveWindow(Window* window) override { removed_count_++; }
 
   void OnWindowVisibilityChanged(Window* window, bool visible) override {
     if (!visibility_info_) {
       visibility_info_.reset(new VisibilityInfo);
       visibility_info_->changed_count = 0;
     }
     visibility_info_->window_visible = window->IsVisible();
     visibility_info_->visible_param = visible;
     visibility_info_->changed_count++;
   }
 
   void OnWindowDestroyed(Window* window) override {
     EXPECT_FALSE(window->parent());
     destroyed_count_++;
   }
 
   void OnWindowPropertyChanged(Window* window,
                                const void* key,
                                intptr_t old) override {
     property_key_ = key;
     old_property_value_ = old;
   }
 
-  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_;
   std::unique_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);
 };
@@ skipping 114 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_P(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.
-  std::unique_ptr<Window> w1(CreateTestWindowWithId(1, root_window()));
-  w1->AddObserver(this);
-  std::unique_ptr<Window> w2(CreateTestWindowWithId(2, w1.get()));
-  w2->AddObserver(this);
-  std::unique_ptr<Window> w3(CreateTestWindowWithId(3, w1.get()));
-  w3->AddObserver(this);
-  std::unique_ptr<Window> w4(CreateTestWindowWithId(4, w3.get()));
-  w4->AddObserver(this);
-
-  EXPECT_EQ(std::string(), TransformNotificationsAndClear());
-
-  gfx::Transform transform;
-  transform.Translate(10, 10);
-  w1->SetTransform(transform);
-
-  EXPECT_EQ("(1,1)(1,2)(1,3)(1,4)", TransformNotificationsAndClear());
-}
-
 TEST_P(WindowTest, AcquireLayer) {
   std::unique_ptr<Window> window1(CreateTestWindowWithId(1, root_window()));
   std::unique_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 910 matching lines @@
                         ::testing::Values(BackendType::CLASSIC,
                                           BackendType::MUS));
 
 INSTANTIATE_TEST_CASE_P(/* no prefix */,
                         WindowObserverTest,
                         ::testing::Values(BackendType::CLASSIC,
                                           BackendType::MUS));
 
 }  // namespace test
 }  // namespace aura