cros: CustomFrameViewAsh avatar icon from a window prop

ash/frame/custom_frame_view_ash.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 "ash/frame/custom_frame_view_ash.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
 #include "ash/frame/frame_border_hit_test.h"
 #include "ash/frame/header_view.h"
 #include "ash/shared/immersive_fullscreen_controller.h"
 #include "ash/shared/immersive_fullscreen_controller_delegate.h"
 #include "ash/shell_port.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_observer.h"
 #include "ash/wm_window.h"
+#include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gfx/image/image_skia.h"
 #include "ui/views/view.h"
 #include "ui/views/view_targeter.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
 namespace ash {
 
 namespace {
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 45 matching lines @@
                                            ui::SHOW_STATE_FULLSCREEN);
     } else {
       window_state->Restore();
     }
     if (immersive_fullscreen_controller_) {
       immersive_fullscreen_controller_->SetEnabled(
           ImmersiveFullscreenController::WINDOW_TYPE_OTHER, enter_fullscreen);
     }
     return true;
   }
+
   // Overridden from aura::WindowObserver:
   void OnWindowDestroying(aura::Window* window) override {
     window_state_->RemoveObserver(this);
     window->RemoveObserver(this);
     window_state_ = nullptr;
   }
+
   // Overridden from wm::WindowStateObserver:
   void OnPostWindowStateTypeChange(wm::WindowState* window_state,
                                    wm::WindowStateType old_type) override {
     if (!window_state->IsFullscreen() && !window_state->IsMinimized() &&
         immersive_fullscreen_controller_ &&
         immersive_fullscreen_controller_->IsEnabled()) {
       immersive_fullscreen_controller_->SetEnabled(
           ImmersiveFullscreenController::WINDOW_TYPE_OTHER, false);
     }
   }
 
   wm::WindowState* window_state_;
   std::unique_ptr<ImmersiveFullscreenController>
       immersive_fullscreen_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(CustomFrameViewAshWindowStateDelegate);
 };
 
 }  // namespace
 
 // static
 bool CustomFrameViewAsh::use_empty_minimum_size_for_test_ = false;
 
 ///////////////////////////////////////////////////////////////////////////////
+// CustomFrameViewAsh::AvatarObserver
+
+// AvatarObserver watches the frame window's avatar icon property and updates
+// HeaderView with it.
+class CustomFrameViewAsh::AvatarObserver : public aura::WindowObserver {
+ public:
+  AvatarObserver(views::Widget* frame, HeaderView* header_view)
+      : frame_window_(frame->GetNativeWindow()), header_view_(header_view) {
+    frame_window_->AddObserver(this);
+  }
+
+  ~AvatarObserver() override {
+    if (frame_window_)
+      frame_window_->RemoveObserver(this);
+  }
+
+  // aura::WindowObserver:
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override {
+    DCHECK_EQ(frame_window_, window);
+    if (key != aura::client::kAvatarIconKey)
+      return;
+
+    gfx::ImageSkia* const avatar_icon =
+        frame_window_->GetProperty(aura::client::kAvatarIconKey);
+    header_view_->SetAvatarIcon(avatar_icon ? *avatar_icon : gfx::ImageSkia());
+  }
+
+  void OnWindowDestroyed(aura::Window* window) override {
+    DCHECK_EQ(frame_window_, window);
+    frame_window_ = nullptr;
+  }
+
+ private:
+  aura::Window* frame_window_;
+  HeaderView* const header_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(AvatarObserver);
+};
+
+///////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh::OverlayView
 
 // View which takes up the entire widget and contains the HeaderView. HeaderView
 // is a child of OverlayView to avoid creating a larger texture than necessary
 // when painting the HeaderView to its own layer.
 class CustomFrameViewAsh::OverlayView : public views::View,
                                         public views::ViewTargeterDelegate {
  public:
   explicit OverlayView(HeaderView* header_view);
   ~OverlayView() override;
@@ skipping 75 matching lines @@
 
 CustomFrameViewAsh::CustomFrameViewAsh(
     views::Widget* frame,
     ImmersiveFullscreenControllerDelegate* immersive_delegate,
     bool enable_immersive,
     mojom::WindowStyle window_style)
     : frame_(frame),
       header_view_(new HeaderView(frame, window_style)),
       overlay_view_(new OverlayView(header_view_)),
       immersive_delegate_(immersive_delegate ? immersive_delegate
-                                             : header_view_) {
+                                             : header_view_),
+      avatar_observer_(base::MakeUnique<AvatarObserver>(frame_, header_view_)) {
   WmWindow* frame_window = WmWindow::Get(frame->GetNativeWindow());
   frame_window->InstallResizeHandleWindowTargeter(nullptr);
   // |header_view_| is set as the non client view's overlay view so that it can
   // overlay the web contents in immersive fullscreen.
   frame->non_client_view()->SetOverlayView(overlay_view_);
   frame_window->aura_window()->SetProperty(
       aura::client::kTopViewColor, header_view_->GetInactiveFrameColor());
 
   // A delegate for a more complex way of fullscreening the window may already
   // be set. This is the case for packaged apps.
@@ skipping 18 matching lines @@
   header_view_->SetFrameColors(active_frame_color, inactive_frame_color);
   WmWindow* frame_window = WmWindow::Get(frame_->GetNativeWindow());
   frame_window->aura_window()->SetProperty(
       aura::client::kTopViewColor, header_view_->GetInactiveFrameColor());
 }
 
 void CustomFrameViewAsh::SetHeaderHeight(base::Optional<int> height) {
   overlay_view_->SetHeaderHeight(height);
 }
 
-views::View* CustomFrameViewAsh::header_view() {
+views::View* CustomFrameViewAsh::GetHeaderView() {
   return header_view_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh, views::NonClientFrameView overrides:
 
 gfx::Rect CustomFrameViewAsh::GetBoundsForClientView() const {
   gfx::Rect client_bounds = bounds();
   client_bounds.Inset(0, NonClientTopBorderHeight(), 0, 0);
   return client_bounds;
@@ skipping 86 matching lines @@
     // The HeaderView is not a child of CustomFrameViewAsh. Redirect the paint
     // to HeaderView instead.
     gfx::RectF to_paint(r);
     views::View::ConvertRectToTarget(this, header_view_, &to_paint);
     header_view_->SchedulePaintInRect(gfx::ToEnclosingRect(to_paint));
   } else {
     views::NonClientFrameView::SchedulePaintInRect(r);
   }
 }
 
-void CustomFrameViewAsh::VisibilityChanged(views::View* starting_from,
-                                           bool is_visible) {
-  if (is_visible)
-    header_view_->UpdateAvatarIcon();
-}
-
-views::View* CustomFrameViewAsh::GetHeaderView() {
-  return header_view_;
-}
-
 const views::View* CustomFrameViewAsh::GetAvatarIconViewForTest() const {
   return header_view_->avatar_icon();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CustomFrameViewAsh, private:
 
 // views::NonClientFrameView:
 bool CustomFrameViewAsh::DoesIntersectRect(const views::View* target,
                                            const gfx::Rect& rect) const {
   CHECK_EQ(target, this);
   // NonClientView hit tests the NonClientFrameView first instead of going in
   // z-order. Return false so that events get to the OverlayView.
   return false;
 }
 
 FrameCaptionButtonContainerView*
 CustomFrameViewAsh::GetFrameCaptionButtonContainerViewForTest() {
   return header_view_->caption_button_container();
 }
 
 int CustomFrameViewAsh::NonClientTopBorderHeight() const {
   return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
 }
 
 }  // namespace ash