Adds OnChildWindowVisibilityChanged to ui::WindowObserver

ui/views/mus/native_widget_mus.cc

 // Copyright 2015 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.
 
+// This has to be before any other includes, else default is picked up.
+// See base/logging for details on this.
+#define NOTIMPLEMENTED_POLICY 5

[James Cook, 2016/10/03 20:33:08]

Gentle pushback: We're already pretty spammy at startup, even with this policy.
Are you sure you want to add these back?

[sky, 2016/10/03 20:52:13]

I realize we're spammy, but I think that's the point. Otherwise we're going to
miss some things. I'll also add its nice to try and bring up a test, see
something logged about NOTIMPLEMENTED and realize it is likely related.

+
 #include "ui/views/mus/native_widget_mus.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 386 matching lines @@
       : native_widget_mus_(native_widget_mus),
         show_state_(ui::mojom::ShowState::DEFAULT) {
     mus_window()->AddObserver(this);
   }
 
   ~MusWindowObserver() override {
     mus_window()->RemoveObserver(this);
   }
 
   // ui::WindowObserver:
-  void OnWindowVisibilityChanging(ui::Window* window) override {
-    native_widget_mus_->OnMusWindowVisibilityChanging(window);
+  void OnWindowVisibilityChanging(ui::Window* window, bool visible) override {
+    native_widget_mus_->OnMusWindowVisibilityChanging(window, visible);
   }
-  void OnWindowVisibilityChanged(ui::Window* window) override {
-    native_widget_mus_->OnMusWindowVisibilityChanged(window);
+  void OnWindowVisibilityChanged(ui::Window* window, bool visible) override {
+    native_widget_mus_->OnMusWindowVisibilityChanged(window, visible);
   }
   void OnWindowPredefinedCursorChanged(ui::Window* window,
                                        ui::mojom::Cursor cursor) override {
     DCHECK_EQ(window, mus_window());
     native_widget_mus_->set_last_cursor(cursor);
   }
   void OnWindowSharedPropertyChanged(
       ui::Window* window,
       const std::string& name,
       const std::vector<uint8_t>* old_data,
@@ skipping 342 matching lines @@
 void NativeWidgetMus::OnWidgetInitDone() {
   // The client area is calculated from the NonClientView. During
   // InitNativeWidget() the NonClientView has not been created. When this
   // function is called the NonClientView has been created, so that we can
   // correctly calculate the client area and push it to the ui::Window.
   UpdateClientArea();
   UpdateHitTestMask();
 }
 
 bool NativeWidgetMus::ShouldUseNativeFrame() const {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
   return false;
 }
 
 bool NativeWidgetMus::ShouldWindowContentsBeTransparent() const {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
   return true;
 }
 
 void NativeWidgetMus::FrameTypeChanged() {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 Widget* NativeWidgetMus::GetWidget() {
   return native_widget_delegate_->AsWidget();
 }
 
 const Widget* NativeWidgetMus::GetWidget() const {
   return native_widget_delegate_->AsWidget();
 }
 
@@ skipping 11 matching lines @@
 
 const ui::Compositor* NativeWidgetMus::GetCompositor() const {
   return window_tree_host_->compositor();
 }
 
 const ui::Layer* NativeWidgetMus::GetLayer() const {
   return content_ ? content_->layer() : nullptr;
 }
 
 void NativeWidgetMus::ReorderNativeViews() {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::ViewRemoved(View* view) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 // These methods are wrong in mojo. They're not usually used to associate
 // data with a window; they are used exclusively in chrome/ to unsafely pass
 // raw pointers around. I can only find two places where we do the "safe"
 // thing (and even that requires casting an integer to a void*). They can't be
 // used safely in a world where we separate things with mojo. They should be
 // removed; not ported.
 void NativeWidgetMus::SetNativeWindowProperty(const char* name, void* value) {
   native_window_properties_[name] = value;
 }
 
 void* NativeWidgetMus::GetNativeWindowProperty(const char* name) const {
   auto it = native_window_properties_.find(name);
   if (it == native_window_properties_.end())
     return nullptr;
   return it->second;
 }
 
 TooltipManager* NativeWidgetMus::GetTooltipManager() const {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
   return nullptr;
 }
 
 void NativeWidgetMus::SetCapture() {
   if (content_)
     content_->SetCapture();
 }
 
 void NativeWidgetMus::ReleaseCapture() {
   if (content_)
@@ skipping 18 matching lines @@
   gfx::Rect bounds = display::Screen::GetScreen()
                          ->GetDisplayNearestWindow(content_)
                          .work_area();
   bounds.ClampToCenteredSize(size);
   window_->SetBounds(bounds);
 }
 
 void NativeWidgetMus::GetWindowPlacement(
       gfx::Rect* bounds,
       ui::WindowShowState* maximized) const {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 bool NativeWidgetMus::SetWindowTitle(const base::string16& title) {
   if (!window_ || is_parallel_widget_in_window_manager())
     return false;
   const char* kWindowTitle_Property =
       ui::mojom::WindowManager::kWindowTitle_Property;
   const base::string16 current_title =
       window_->HasSharedProperty(kWindowTitle_Property)
           ? window_->GetSharedProperty<base::string16>(kWindowTitle_Property)
@@ skipping 97 matching lines @@
 
 void NativeWidgetMus::SetSize(const gfx::Size& size) {
   if (!window_tree_host_)
     return;
 
   gfx::Rect bounds = window_tree_host_->GetBounds();
   SetBounds(gfx::Rect(bounds.origin(), size));
 }
 
 void NativeWidgetMus::StackAbove(gfx::NativeView native_view) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::StackAtTop() {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::StackBelow(gfx::NativeView native_view) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::SetShape(std::unique_ptr<SkRegion> shape) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::Close() {
   Hide();
   if (!close_widget_factory_.HasWeakPtrs()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&NativeWidgetMus::CloseNow,
                               close_widget_factory_.GetWeakPtr()));
   }
 }
@@ skipping 12 matching lines @@
   if (!(window_ && window_tree_host_))
     return;
 
   // NOTE: |window_tree_host_| and |window_| visibility is updated in
   // OnMusWindowVisibilityChanged().
   window_->SetVisible(false);
 }
 
 void NativeWidgetMus::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::ShowWithWindowState(ui::WindowShowState state) {
   if (!(window_ && window_tree_host_))
     return;
 
   // NOTE: |window_tree_host_| and |window_| visibility is updated in
   // OnMusWindowVisibilityChanged().
   window_->SetVisible(true);
   if (native_widget_delegate_->CanActivate()) {
@@ skipping 99 matching lines @@
 bool NativeWidgetMus::IsFullscreen() const {
   return GetShowState(window_) == ui::mojom::ShowState::FULLSCREEN;
 }
 
 void NativeWidgetMus::SetOpacity(float opacity) {
   if (window_)
     window_->SetOpacity(opacity);
 }
 
 void NativeWidgetMus::FlashFrame(bool flash_frame) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::RunShellDrag(View* view,
                                    const ui::OSExchangeData& data,
                                    const gfx::Point& location,
                                    int drag_operations,
                                    ui::DragDropTypes::DragEventSource source) {
   if (window_)
     views::RunShellDrag(content_, data, location, drag_operations, source);
 }
@@ skipping 12 matching lines @@
   // we support right now. If native_type() == kCursorCustom, than we should
   // also send an image, but as the cursor code is currently written, the image
   // is in a platform native format that's already uploaded to the window
   // server.
   ui::mojom::Cursor new_cursor = ui::mojom::Cursor(cursor.native_type());
   if (last_cursor_ != new_cursor)
     window_->SetPredefinedCursor(new_cursor);
 }
 
 bool NativeWidgetMus::IsMouseEventsEnabled() const {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
   return true;
 }
 
 void NativeWidgetMus::ClearNativeFocus() {
   if (!IsActive())
     return;
   ui::Window* focused =
       window_ ? window_->window_tree()->GetFocusedWindow() : nullptr;
   if (focused && window_->Contains(focused) && focused != window_)
     window_->SetFocus();
   // Move aura-focus back to |content_|, so that the Widget still receives
   // events correctly.
   aura::client::GetFocusClient(content_)->ResetFocusWithinActiveWindow(
       content_);
 }
 
 gfx::Rect NativeWidgetMus::GetWorkAreaBoundsInScreen() const {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
   return gfx::Rect();
 }
 
 Widget::MoveLoopResult NativeWidgetMus::RunMoveLoop(
     const gfx::Vector2d& drag_offset,
     Widget::MoveLoopSource source,
     Widget::MoveLoopEscapeBehavior escape_behavior) {
   ReleaseCapture();
 
   base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
@@ skipping 15 matching lines @@
   run_loop.Run();
 
   return success ? Widget::MOVE_LOOP_SUCCESSFUL : Widget::MOVE_LOOP_CANCELED;
 }
 
 void NativeWidgetMus::EndMoveLoop() {
   window_->CancelWindowMove();
 }
 
 void NativeWidgetMus::SetVisibilityChangedAnimationsEnabled(bool value) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::SetVisibilityAnimationDuration(
     const base::TimeDelta& duration) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 void NativeWidgetMus::SetVisibilityAnimationTransition(
     Widget::VisibilityTransition transition) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 ui::NativeTheme* NativeWidgetMus::GetNativeTheme() const {
   return ui::NativeThemeAura::instance();
 }
 
 void NativeWidgetMus::OnRootViewLayout() {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 bool NativeWidgetMus::IsTranslucentWindowOpacitySupported() const {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
   return true;
 }
 
 void NativeWidgetMus::OnSizeConstraintsChanged() {
   if (!window_ || is_parallel_widget_in_window_manager())
     return;
 
   window_->SetSharedProperty<int32_t>(
       ui::mojom::WindowManager::kResizeBehavior_Property,
       ResizeBehaviorFromDelegate(GetWidget()->widget_delegate()));
 }
 
 void NativeWidgetMus::RepostNativeEvent(gfx::NativeEvent native_event) {
-  // NOTIMPLEMENTED();
+  NOTIMPLEMENTED();
 }
 
 std::string NativeWidgetMus::GetName() const {
   return window_->GetName();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMus, aura::WindowDelegate implementation:
 
 gfx::Size NativeWidgetMus::GetMinimumSize() const {
@@ skipping 166 matching lines @@
   std::unique_ptr<ui::Event> event = ui::Event::Clone(event_in);
   // TODO(markdittmer): This should be this->OnEvent(event.get()), but that
   // can't happen until IME is refactored out of in WindowTreeHostMus.
   platform_window_delegate()->DispatchEvent(event.get());
   // NOTE: |this| may be deleted.
 
   ack_handler.set_handled(event->handled());
   // |ack_handler| acks the event on destruction if necessary.
 }
 
-void NativeWidgetMus::OnMusWindowVisibilityChanging(ui::Window* window) {
-  if (window == window_) {
-    native_widget_delegate_->OnNativeWidgetVisibilityChanging(
-        !window->visible());
-  }
+void NativeWidgetMus::OnMusWindowVisibilityChanging(ui::Window* window,
+                                                    bool visible) {
+  if (window == window_)
+    native_widget_delegate_->OnNativeWidgetVisibilityChanging(visible);
 }
 
-void NativeWidgetMus::OnMusWindowVisibilityChanged(ui::Window* window) {
+void NativeWidgetMus::OnMusWindowVisibilityChanged(ui::Window* window,
+                                                   bool visible) {
   if (window != window_)
     return;
 
-  if (window->visible()) {
+  if (visible) {
     window_tree_host_->Show();
     GetNativeWindow()->Show();
   } else {
     window_tree_host_->Hide();
     GetNativeWindow()->Hide();
   }
-  native_widget_delegate_->OnNativeWidgetVisibilityChanged(window->visible());
+  native_widget_delegate_->OnNativeWidgetVisibilityChanged(visible);
 }
 
 void NativeWidgetMus::UpdateHitTestMask() {
   // The window manager (or other underlay window provider) is not allowed to
   // set a hit test mask, as that could interfere with a client app mask.
   if (is_parallel_widget_in_window_manager())
     return;
 
   if (!native_widget_delegate_->HasHitTestMask()) {
     window_->ClearHitTestMask();
     return;
   }
 
   gfx::Path mask_path;
   native_widget_delegate_->GetHitTestMask(&mask_path);
   // TODO(jamescook): Use the full path for the mask.
   gfx::Rect mask_rect =
       gfx::ToEnclosingRect(gfx::SkRectToRectF(mask_path.getBounds()));
   window_->SetHitTestMask(mask_rect);
 }
 
 }  // namespace views