Always paint the header edges for non-maximized windows

ash/wm/header_painter.cc

 // Copyright 2013 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/wm/header_painter.h"
 
 #include <vector>
 
 #include "ash/root_window_controller.h"
 #include "ash/wm/caption_buttons/frame_caption_button_container_view.h"
@@ skipping 122 matching lines @@
 namespace ash {
 
 ///////////////////////////////////////////////////////////////////////////////
 // HeaderPainter, public:
 
 HeaderPainter::HeaderPainter()
     : frame_(NULL),
       header_view_(NULL),
       window_icon_(NULL),
       caption_button_container_(NULL),
-      window_(NULL),
       header_height_(0),
       top_left_corner_(NULL),
       top_edge_(NULL),
       top_right_corner_(NULL),
       header_left_edge_(NULL),
       header_right_edge_(NULL),
       previous_theme_frame_id_(0),
       previous_theme_frame_overlay_id_(0),
       crossfade_theme_frame_id_(0),
       crossfade_theme_frame_overlay_id_(0) {}
 
 HeaderPainter::~HeaderPainter() {
-  // Sometimes we are destroyed before the window closes, so ensure we clean up.
-  if (window_)
-    window_->RemoveObserver(this);
 }
 
 void HeaderPainter::Init(
     views::Widget* frame,
     views::View* header_view,
     views::View* window_icon,
     FrameCaptionButtonContainerView* caption_button_container) {
   DCHECK(frame);
   DCHECK(header_view);
   // window_icon may be NULL.
   DCHECK(caption_button_container);
   frame_ = frame;
   header_view_ = header_view;
   window_icon_ = window_icon;
   caption_button_container_ = caption_button_container;
 
   // Window frame image parts.
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   top_left_corner_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP_LEFT).ToImageSkia();
   top_edge_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP).ToImageSkia();
   top_right_corner_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_TOP_RIGHT).ToImageSkia();
   header_left_edge_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_LEFT).ToImageSkia();
   header_right_edge_ =
       rb.GetImageNamed(IDR_AURA_WINDOW_HEADER_SHADE_RIGHT).ToImageSkia();
-
-  window_ = frame->GetNativeWindow();
-
-  // Observer removes itself in OnWindowDestroying() below, or in the destructor
-  // if we go away before the window.
-  window_->AddObserver(this);
-
-  // Solo-window header updates are handled by the WorkspaceLayoutManager when
-  // this window is added to the desktop.
 }
 
 // static
 gfx::Rect HeaderPainter::GetBoundsForClientView(
     int header_height,
     const gfx::Rect& window_bounds) {
   gfx::Rect client_bounds(window_bounds);
   client_bounds.Inset(0, header_height, 0, 0);
   return client_bounds;
 }
@@ skipping 121 matching lines @@
                               theme_frame,
                               theme_frame_overlay,
                               paint,
                               GetHeaderLocalBounds(),
                               corner_radius,
                               GetThemeBackgroundXInset());
 
   previous_theme_frame_id_ = theme_frame_id;
   previous_theme_frame_overlay_id_ = theme_frame_overlay_id;
 
-  // We don't need the extra lightness in the edges when we're at the top edge
-  // of the screen or when the header's corners are not rounded.
-  //
-  // TODO(sky): this isn't quite right. What we really want is a method that
-  // returns bounds ignoring transforms on certain windows (such as workspaces)
-  // and is relative to the root.
-  if (frame_->GetNativeWindow()->bounds().y() == 0 || corner_radius == 0)
+  // We don't need the extra lightness in the edges when the window is maximized
+  // or fullscreen.
+  if (frame_->IsMaximized() || frame_->IsFullscreen())
     return;
 
   // Draw the top corners and edge.
   int top_left_width = top_left_corner_->width();
   int top_left_height = top_left_corner_->height();
   canvas->DrawImageInt(*top_left_corner_,
                        0, 0, top_left_width, top_left_height,
                        0, 0, top_left_width, top_left_height,
                        false);
   canvas->TileImageInt(*top_edge_,
@@ skipping 94 matching lines @@
   previous_theme_frame_id_ = 0;
   previous_theme_frame_overlay_id_ = 0;
 
   if (crossfade_animation_.get() && crossfade_animation_->is_animating()) {
     crossfade_animation_.reset();
     header_view_->SchedulePaintInRect(GetHeaderLocalBounds());
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// aura::WindowObserver overrides:
-
-void HeaderPainter::OnWindowDestroying(aura::Window* destroying) {
-  DCHECK_EQ(window_, destroying);
-
-  // Must be removed here and not in the destructor, as the aura::Window is
-  // already destroyed when our destructor runs.
-  window_->RemoveObserver(this);
-
-  window_ = NULL;
-}
-
-void HeaderPainter::OnWindowBoundsChanged(aura::Window* window,
-                                         const gfx::Rect& old_bounds,
-                                         const gfx::Rect& new_bounds) {
-  // TODO(sky): this isn't quite right. What we really want is a method that
-  // returns bounds ignoring transforms on certain windows (such as workspaces).
-  if ((!frame_->IsMaximized() && !frame_->IsFullscreen()) &&
-      ((old_bounds.y() == 0 && new_bounds.y() != 0) ||
-       (old_bounds.y() != 0 && new_bounds.y() == 0))) {
-    SchedulePaintForHeader();
-  }
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // gfx::AnimationDelegate overrides:
 
 void HeaderPainter::AnimationProgressed(const gfx::Animation* animation) {
   header_view_->SchedulePaintInRect(GetHeaderLocalBounds());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // HeaderPainter, private:
 
 gfx::Rect HeaderPainter::GetHeaderLocalBounds() const {
@@ skipping 10 matching lines @@
   return caption_button_container_->y() +
       caption_button_container_->height() / 2;
 }
 
 int HeaderPainter::GetHeaderCornerRadius() const {
   bool square_corners = (frame_->IsMaximized() || frame_->IsFullscreen());
   const int kCornerRadius = 2;
   return square_corners ? 0 : kCornerRadius;
 }
 
-void HeaderPainter::SchedulePaintForHeader() {
-  int top_left_height = top_left_corner_->height();
-  int top_right_height = top_right_corner_->height();
-  header_view_->SchedulePaintInRect(
-      gfx::Rect(0, 0, header_view_->width(),
-                std::max(top_left_height, top_right_height)));
-}
-
 gfx::Rect HeaderPainter::GetTitleBounds(const gfx::Font& title_font) {
   int title_x = GetTitleOffsetX();
   // Center the text with respect to the caption button container. This way it
   // adapts to the caption button height and aligns exactly with the window
   // icon. Don't use |window_icon_| for this computation as it may be NULL.
   int title_y = GetCaptionButtonContainerCenterY() - title_font.GetHeight() / 2;
   return gfx::Rect(
       title_x,
       std::max(0, title_y),
       std::max(0, caption_button_container_->x() - kTitleLogoSpacing - title_x),
       title_font.GetHeight());
 }
 
 }  // namespace ash