Show avatar icon on V2 app's frame

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 "ash/ash_switches.h"
 #include "ash/frame/caption_buttons/frame_caption_button_container_view.h"
 #include "ash/frame/caption_buttons/frame_maximize_button.h"
 #include "ash/frame/caption_buttons/frame_maximize_button_observer.h"
 #include "ash/frame/frame_border_hit_test_controller.h"
+#include "ash/frame/frame_util.h"
 #include "ash/frame/header_painter.h"
+#include "ash/session_state_delegate.h"
+#include "ash/shell.h"
 #include "ash/wm/immersive_fullscreen_controller.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_observer.h"
 #include "base/command_line.h"
 #include "base/debug/leak_annotations.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_list.h"
+#include "ui/gfx/image/image.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size.h"
+#include "ui/views/controls/image_view.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/native_widget_aura.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 #include "ui/views/widget/widget_deletion_observer.h"
 
 namespace {
 
 const gfx::FontList& GetTitleFontList() {
   static const gfx::FontList* title_font_list =
@@ skipping 111 matching lines @@
 
   // Returns the amount of the view's pixels which should be on screen.
   int GetPreferredOnScreenHeight() const;
 
   // Returns the view's preferred height.
   int GetPreferredHeight() const;
 
   // Returns the view's minimum width.
   int GetMinimumWidth() const;
 
+  // Updates the avatar icon based on the current state
+  // of the SessionStateDelegate::ShouldShowAvatar and
+  // SessionStateDelegate::GetUserImage.
+  void UpdateAvatarIcon();
+
   // views::View overrides:
   virtual void Layout() OVERRIDE;
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 
   HeaderPainter* header_painter() {
     return header_painter_.get();
   }
 
+  views::View* avatar_icon() const {
+    return avatar_icon_;
+  }
+
  private:
   // ImmersiveFullscreenController::Delegate overrides:
   virtual void OnImmersiveRevealStarted() OVERRIDE;
   virtual void OnImmersiveRevealEnded() OVERRIDE;
   virtual void OnImmersiveFullscreenExited() OVERRIDE;
   virtual void SetVisibleFraction(double visible_fraction) OVERRIDE;
   virtual std::vector<gfx::Rect> GetVisibleBoundsInScreen() const OVERRIDE;
 
   // FrameMaximizeButtonObserver overrides:
   virtual void OnMaximizeBubbleShown(views::Widget* bubble) OVERRIDE;
 
   // The widget that the caption buttons act on.
   views::Widget* frame_;
 
+  views::ImageView* avatar_icon_;
+
   // Helper for painting the header.
   scoped_ptr<HeaderPainter> header_painter_;
 
   // View which contains the window caption buttons.
   FrameCaptionButtonContainerView* caption_button_container_;
 
   // The maximize bubble widget. |maximize_bubble_| may be non-NULL but have
   // been already destroyed.
   views::Widget* maximize_bubble_;
 
   // Keeps track of whether |maximize_bubble_| is still alive.
   scoped_ptr<views::WidgetDeletionObserver> maximize_bubble_lifetime_observer_;
 
   // The fraction of the header's height which is visible while in fullscreen.
   // This value is meaningless when not in fullscreen.
   double fullscreen_visible_fraction_;
 
   DISALLOW_COPY_AND_ASSIGN(HeaderView);
 };
 
 CustomFrameViewAsh::HeaderView::HeaderView(views::Widget* frame)
     : frame_(frame),
+      avatar_icon_(NULL),
       header_painter_(new ash::HeaderPainter),
       caption_button_container_(NULL),
       maximize_bubble_(NULL),
       fullscreen_visible_fraction_(0) {
   // Unfortunately, there is no views::WidgetDelegate::CanMinimize(). Assume
   // that the window frame can be minimized if it can be maximized.
   FrameCaptionButtonContainerView::MinimizeAllowed minimize_allowed =
       frame_->widget_delegate()->CanMaximize() ?
           FrameCaptionButtonContainerView::MINIMIZE_ALLOWED :
           FrameCaptionButtonContainerView::MINIMIZE_DISALLOWED;
@@ skipping 35 matching lines @@
 int CustomFrameViewAsh::HeaderView::GetPreferredHeight() const {
   // Reserve enough space to see the buttons and the separator line.
   return caption_button_container_->bounds().bottom() +
       header_painter_->HeaderContentSeparatorSize();
 }
 
 int CustomFrameViewAsh::HeaderView::GetMinimumWidth() const {
   return header_painter_->GetMinimumHeaderWidth();
 }
 
+void CustomFrameViewAsh::HeaderView::UpdateAvatarIcon() {
+  SessionStateDelegate* delegate =
+      Shell::GetInstance()->session_state_delegate();
+  aura::Window* window = frame_->GetNativeView();
+  bool show = delegate->ShouldShowAvatar(window);
+  if (!show && avatar_icon_) {

[Mr4D (OOO till 08-26), 2014/03/14 22:01:30]

This is confusing to read. Why not:

if (!delegate->ShouldShowAvatar(window)) {
  if (!avatar_icon)
     return;
  delete avatar_icon;
  avatar_icon = NULL;
} else {
  ..
}
...

[oshima, 2014/03/15 01:32:32]

you're absolutely right. fixed.

+    delete avatar_icon_;
+    avatar_icon_ = NULL;
+  } else if (show) {
+    gfx::ImageSkia image = GetAvatarImageForContext(
+        delegate->GetBrowserContextForWindow(window)).AsImageSkia();
+    DCHECK(!image.isNull());
+    if (!avatar_icon_) {
+      avatar_icon_ = new views::ImageView();
+      AddChildView(avatar_icon_);
+    }
+    avatar_icon_->SetImage(image);
+    avatar_icon_->SetBounds(0, 0, image.width(), image.height());
+    avatar_icon_->SchedulePaint();
+  } else {
+    return;
+  }
+  header_painter_->UpdateAvatarIcon(avatar_icon_);
+  Layout();
+}
+
 void CustomFrameViewAsh::HeaderView::Layout() {
   header_painter_->LayoutHeader();
   header_painter_->set_header_height(GetPreferredHeight());
 }
 
 void CustomFrameViewAsh::HeaderView::OnPaint(gfx::Canvas* canvas) {
   bool paint_as_active =
       frame_->non_client_view()->frame_view()->ShouldPaintAsActive();
   caption_button_container_->SetPaintAsActive(paint_as_active);
 
@@ skipping 130 matching lines @@
   frame->non_client_view()->SetOverlayView(new OverlayView(header_view_));
 
   // A delegate for a more complex way of fullscreening the window may already
   // be set. This is the case for packaged apps.
   wm::WindowState* window_state = wm::GetWindowState(frame->GetNativeWindow());
   if (!window_state->HasDelegate()) {
     window_state->SetDelegate(scoped_ptr<wm::WindowStateDelegate>(
         new CustomFrameViewAshWindowStateDelegate(
             window_state, this)));
   }
+  header_view_->UpdateAvatarIcon();
 }
 
 CustomFrameViewAsh::~CustomFrameViewAsh() {
 }
 
 void CustomFrameViewAsh::InitImmersiveFullscreenControllerForView(
     ImmersiveFullscreenController* immersive_fullscreen_controller) {
   immersive_fullscreen_controller->Init(header_view_, frame_, header_view_);
 }
 
@@ skipping 79 matching lines @@
     views::NonClientFrameView::SchedulePaintInRect(r);
   }
 }
 
 bool CustomFrameViewAsh::HitTestRect(const gfx::Rect& rect) const {
   // NonClientView hit tests the NonClientFrameView first instead of going in
   // z-order. Return false so that events get to the OverlayView.
   return false;
 }
 
+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:
 
 int CustomFrameViewAsh::NonClientTopBorderHeight() const {
   return frame_->IsFullscreen() ? 0 : header_view_->GetPreferredHeight();
 }
 
 }  // namespace ash