Remove "solo window" feature

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"
-#include "ash/wm/solo_window_tracker.h"
 #include "base/logging.h"  // DCHECK
 #include "grit/ash_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
@@ skipping 30 matching lines @@
 const SkColor kHeaderContentSeparatorColor = SkColorSetRGB(128, 128, 128);
 // In the pre-Ash era the web content area had a frame along the left edge, so
 // user-generated theme images for the new tab page assume they are shifted
 // right relative to the header.  Now that we have removed the left edge frame
 // we need to copy the theme image for the window header from a few pixels
 // inset to preserve alignment with the NTP image, or else we'll break a bunch
 // of existing themes.  We do something similar on OS X for the same reason.
 const int kThemeFrameImageInsetX = 5;
 // Duration of crossfade animation for activating and deactivating frame.
 const int kActivationCrossfadeDurationMs = 200;
-// Alpha/opacity value for fully-opaque headers.
-const int kFullyOpaque = 255;
 
 // Tiles an image into an area, rounding the top corners. Samples |image|
 // starting |image_inset_x| pixels from the left of the image.
 void TileRoundRect(gfx::Canvas* canvas,
                    const gfx::ImageSkia& image,
                    const SkPaint& paint,
                    const gfx::Rect& bounds,
                    int top_left_corner_radius,
                    int top_right_corner_radius,
                    int image_inset_x) {
@@ skipping 54 matching lines @@
     temporary_canvas.DrawImageInt(*frame_overlay_image, 0, 0);
     TileRoundRect(canvas, gfx::ImageSkia(temporary_canvas.ExtractImageRep()),
         paint, bounds, corner_radius, corner_radius, 0);
   }
 }
 
 }  // namespace
 
 namespace ash {
 
-// static
-int HeaderPainter::kActiveWindowOpacity = 255;  // 1.0
-int HeaderPainter::kInactiveWindowOpacity = 255;  // 1.0
-int HeaderPainter::kSoloWindowOpacity = 77;  // 0.3
-
 ///////////////////////////////////////////////////////////////////////////////
 // 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),
-      previous_opacity_(0),
       crossfade_theme_frame_id_(0),
-      crossfade_theme_frame_overlay_id_(0),
-      crossfade_opacity_(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,
@@ skipping 78 matching lines @@
 
 int HeaderPainter::GetRightInset() const {
   return caption_button_container_->GetPreferredSize().width();
 }
 
 int HeaderPainter::GetThemeBackgroundXInset() const {
   return kThemeFrameImageInsetX;
 }
 
 void HeaderPainter::PaintHeader(gfx::Canvas* canvas,
-                                HeaderMode header_mode,
                                 int theme_frame_id,
                                 int theme_frame_overlay_id) {
   bool initial_paint = (previous_theme_frame_id_ == 0);
   if (!initial_paint &&
       (previous_theme_frame_id_ != theme_frame_id ||
        previous_theme_frame_overlay_id_ != theme_frame_overlay_id)) {
     aura::Window* parent = frame_->GetNativeWindow()->parent();
     // Don't animate the header if the parent (a workspace) is already
     // animating. Doing so results in continually painting during the animation
     // and gives a slower frame rate.
     // TODO(sky): expose a better way to determine this rather than assuming
     // the parent is a workspace.
     bool parent_animating = parent &&
         (parent->layer()->GetAnimator()->IsAnimatingProperty(
             ui::LayerAnimationElement::OPACITY) ||
          parent->layer()->GetAnimator()->IsAnimatingProperty(
              ui::LayerAnimationElement::VISIBILITY));
     if (!parent_animating) {
       crossfade_animation_.reset(new gfx::SlideAnimation(this));
       crossfade_theme_frame_id_ = previous_theme_frame_id_;
       crossfade_theme_frame_overlay_id_ = previous_theme_frame_overlay_id_;
-      crossfade_opacity_ = previous_opacity_;
       crossfade_animation_->SetSlideDuration(kActivationCrossfadeDurationMs);
       crossfade_animation_->Show();
     } else {
       crossfade_animation_.reset();
     }
   }
 
-  int opacity =
-      GetHeaderOpacity(header_mode, theme_frame_id, theme_frame_overlay_id);
   ui::ThemeProvider* theme_provider = frame_->GetThemeProvider();
   gfx::ImageSkia* theme_frame = theme_provider->GetImageSkiaNamed(
       theme_frame_id);
   gfx::ImageSkia* theme_frame_overlay = NULL;
   if (theme_frame_overlay_id != 0) {
     theme_frame_overlay = theme_provider->GetImageSkiaNamed(
         theme_frame_overlay_id);
   }
 
   int corner_radius = GetHeaderCornerRadius();
   SkPaint paint;
 
   if (crossfade_animation_.get() && crossfade_animation_->is_animating()) {
     gfx::ImageSkia* crossfade_theme_frame =
         theme_provider->GetImageSkiaNamed(crossfade_theme_frame_id_);
     gfx::ImageSkia* crossfade_theme_frame_overlay = NULL;
     if (crossfade_theme_frame_overlay_id_ != 0) {
       crossfade_theme_frame_overlay = theme_provider->GetImageSkiaNamed(
           crossfade_theme_frame_overlay_id_);
     }
     if (!crossfade_theme_frame ||
         (crossfade_theme_frame_overlay_id_ != 0 &&
          !crossfade_theme_frame_overlay)) {
       // Reset the animation. This case occurs when the user switches the theme
       // that they are using.
       crossfade_animation_.reset();
-      paint.setAlpha(opacity);
     } else {
-      double current_value = crossfade_animation_->GetCurrentValue();
-      int old_alpha = (1 - current_value) * crossfade_opacity_;
-      int new_alpha = current_value * opacity;
+      int old_alpha = crossfade_animation_->CurrentValueBetween(255, 0);
+      int new_alpha = 255 - old_alpha;
 
       // Draw the old header background, clipping the corners to be rounded.
       paint.setAlpha(old_alpha);
       paint.setXfermodeMode(SkXfermode::kPlus_Mode);
       PaintFrameImagesInRoundRect(canvas,
                                   crossfade_theme_frame,
                                   crossfade_theme_frame_overlay,
                                   paint,
                                   GetHeaderLocalBounds(),
                                   corner_radius,
                                   GetThemeBackgroundXInset());
 
       paint.setAlpha(new_alpha);
     }
-  } else {
-    paint.setAlpha(opacity);
   }
 
   // Draw the header background, clipping the corners to be rounded.
   PaintFrameImagesInRoundRect(canvas,
                               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;
-  previous_opacity_ = opacity;
 
   // 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)
     return;
 
@@ skipping 157 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;
 }
 
-int HeaderPainter::GetHeaderOpacity(
-    HeaderMode header_mode,
-    int theme_frame_id,
-    int theme_frame_overlay_id) const {
-  // User-provided themes are painted fully opaque.
-  ui::ThemeProvider* theme_provider = frame_->GetThemeProvider();
-  if (theme_provider->HasCustomImage(theme_frame_id) ||
-      (theme_frame_overlay_id != 0 &&
-       theme_provider->HasCustomImage(theme_frame_overlay_id))) {
-    return kFullyOpaque;
-  }
-
-  // Maximized and fullscreen windows are fully opaque.
-  if (frame_->IsMaximized() || frame_->IsFullscreen())
-    return kFullyOpaque;
-
-  // Solo header is very transparent.
-  ash::SoloWindowTracker* solo_window_tracker =
-      internal::RootWindowController::ForWindow(window_)->solo_window_tracker();
-  if (solo_window_tracker &&
-      solo_window_tracker->GetWindowWithSoloHeader() == window_) {
-    return kSoloWindowOpacity;
-  }
-
-  // Otherwise, change transparency based on window activation status.
-  if (header_mode == ACTIVE)
-    return kActiveWindowOpacity;
-  return kInactiveWindowOpacity;
-}
-
 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