Add a drop shadow to the fullscreen exit bubble on windows.

views/bubble/bubble_border.cc

 // Copyright (c) 2011 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 "views/bubble/bubble_border.h"
 
 #include <algorithm>  // for std::max
 
 #include "base/logging.h"
 #include "grit/ui_resources.h"
 #include "grit/ui_resources_standard.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/path.h"
 
 namespace views {
 
 // static
-SkBitmap* BubbleBorder::left_ = NULL;
-SkBitmap* BubbleBorder::top_left_ = NULL;
-SkBitmap* BubbleBorder::top_ = NULL;
-SkBitmap* BubbleBorder::top_right_ = NULL;
-SkBitmap* BubbleBorder::right_ = NULL;
-SkBitmap* BubbleBorder::bottom_right_ = NULL;
-SkBitmap* BubbleBorder::bottom_ = NULL;
-SkBitmap* BubbleBorder::bottom_left_ = NULL;
-SkBitmap* BubbleBorder::top_arrow_ = NULL;
-SkBitmap* BubbleBorder::bottom_arrow_ = NULL;
-SkBitmap* BubbleBorder::left_arrow_ = NULL;
-SkBitmap* BubbleBorder::right_arrow_ = NULL;
-
-// static
-int BubbleBorder::arrow_offset_;
+struct BorderImages* BubbleBorder::normal_images_ = NULL;
+struct BorderImages* BubbleBorder::shadow_images_ = NULL;
 
 // The height inside the arrow image, in pixels.
 static const int kArrowInteriorHeight = 7;
 
 gfx::Rect BubbleBorder::GetBounds(const gfx::Rect& position_relative_to,
                                   const gfx::Size& contents_size) const {
   // Desired size is size of contents enlarged by the size of the border images.
   gfx::Size border_size(contents_size);
   gfx::Insets insets;
   GetInsets(&insets);
@@ skipping 119 matching lines @@
   GetInsets(&insets);
   border_size.Enlarge(insets.left() + insets.right(),
                       insets.top() + insets.bottom());
   offset = std::max(arrow_offset_,
       std::min(offset, (is_arrow_on_horizontal(arrow_location_) ?
           border_size.width() : border_size.height()) - arrow_offset_));
   override_arrow_offset_ = offset;
   return override_arrow_offset_;
 }
 
-// static
-void BubbleBorder::InitClass() {
-  static bool initialized = false;
-  if (!initialized) {
-    // Load images.
+void BubbleBorder::InitClass(Shadow shadow) {
+  if (shadow == SHADOW && shadow_images_ == NULL) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    left_ = rb.GetBitmapNamed(IDR_BUBBLE_L);
-    top_left_ = rb.GetBitmapNamed(IDR_BUBBLE_TL);
-    top_ = rb.GetBitmapNamed(IDR_BUBBLE_T);
-    top_right_ = rb.GetBitmapNamed(IDR_BUBBLE_TR);
-    right_ = rb.GetBitmapNamed(IDR_BUBBLE_R);
-    bottom_right_ = rb.GetBitmapNamed(IDR_BUBBLE_BR);
-    bottom_ = rb.GetBitmapNamed(IDR_BUBBLE_B);
-    bottom_left_ = rb.GetBitmapNamed(IDR_BUBBLE_BL);
-    left_arrow_ = rb.GetBitmapNamed(IDR_BUBBLE_L_ARROW);
-    top_arrow_ = rb.GetBitmapNamed(IDR_BUBBLE_T_ARROW);
-    right_arrow_ = rb.GetBitmapNamed(IDR_BUBBLE_R_ARROW);
-    bottom_arrow_ = rb.GetBitmapNamed(IDR_BUBBLE_B_ARROW);
+    shadow_images_ = new BorderImages();
+    shadow_images_->left = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_L);
+    shadow_images_->top_left = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_TL);
+    shadow_images_->top = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_T);
+    shadow_images_->top_right = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_TR);
+    shadow_images_->right = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_R);
+    shadow_images_->bottom_right = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_BR);
+    shadow_images_->bottom = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_B);
+    shadow_images_->bottom_left = rb.GetBitmapNamed(IDR_BUBBLE_SHADOW_BL);
+    shadow_images_->left_arrow = new SkBitmap();
+    shadow_images_->top_arrow = new SkBitmap();
+    shadow_images_->right_arrow = new SkBitmap();
+    shadow_images_->bottom_arrow = new SkBitmap();
+  } else if (shadow == NO_SHADOW && normal_images_ == NULL) {
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+    normal_images_ = new BorderImages();
+    normal_images_->left = rb.GetBitmapNamed(IDR_BUBBLE_L);
+    normal_images_->top_left = rb.GetBitmapNamed(IDR_BUBBLE_TL);
+    normal_images_->top = rb.GetBitmapNamed(IDR_BUBBLE_T);
+    normal_images_->top_right = rb.GetBitmapNamed(IDR_BUBBLE_TR);
+    normal_images_->right = rb.GetBitmapNamed(IDR_BUBBLE_R);
+    normal_images_->bottom_right = rb.GetBitmapNamed(IDR_BUBBLE_BR);
+    normal_images_->bottom = rb.GetBitmapNamed(IDR_BUBBLE_B);
+    normal_images_->bottom_left = rb.GetBitmapNamed(IDR_BUBBLE_BL);
+    normal_images_->left_arrow = rb.GetBitmapNamed(IDR_BUBBLE_L_ARROW);
+    normal_images_->top_arrow = rb.GetBitmapNamed(IDR_BUBBLE_T_ARROW);
+    normal_images_->right_arrow = rb.GetBitmapNamed(IDR_BUBBLE_R_ARROW);
+    normal_images_->bottom_arrow = rb.GetBitmapNamed(IDR_BUBBLE_B_ARROW);
+  }
 
-    // Calculate horizontal and vertical insets for arrow by ensuring that
-    // the widest arrow and corner images will have enough room to avoid overlap
-    int offset_x =
-        (std::max(top_arrow_->width(), bottom_arrow_->width()) / 2) +
-        std::max(std::max(top_left_->width(), top_right_->width()),
-                 std::max(bottom_left_->width(), bottom_right_->width()));
-    int offset_y =
-        (std::max(left_arrow_->height(), right_arrow_->height()) / 2) +
-        std::max(std::max(top_left_->height(), top_right_->height()),
-                 std::max(bottom_left_->height(), bottom_right_->height()));
-    arrow_offset_ = std::max(offset_x, offset_y);
+  struct BorderImages* images =
+      shadow == SHADOW ? shadow_images_ : normal_images_;
+  left_ = images->left;
+  top_left_ = images->top_left;
+  top_ = images->top;
+  top_right_ = images->top_right;
+  right_ = images->right;
+  bottom_right_ = images->bottom_right;
+  bottom_ = images->bottom;
+  bottom_left_ = images->bottom_left;
+  left_arrow_ = images->left_arrow;
+  top_arrow_ = images->top_arrow;
+  right_arrow_ = images->right_arrow;
+  bottom_arrow_ = images->bottom_arrow;
 
-    initialized = true;
-  }
+  // Calculate horizontal and vertical insets for arrow by ensuring that
+  // the widest arrow and corner images will have enough room to avoid overlap
+  int offset_x =
+      (std::max(top_arrow_->width(), bottom_arrow_->width()) / 2) +
+      std::max(std::max(top_left_->width(), top_right_->width()),
+               std::max(bottom_left_->width(), bottom_right_->width()));
+  int offset_y =
+      (std::max(left_arrow_->height(), right_arrow_->height()) / 2) +
+      std::max(std::max(top_left_->height(), top_right_->height()),
+               std::max(bottom_left_->height(), bottom_right_->height()));
+  arrow_offset_ = std::max(offset_x, offset_y);

[sky, 2011/11/15 05:06:37]

This method is poorly named now that it sets both class and non-class state.
Refactor it into:
static BorderImages* GetBorderImages(Shadow shadow_type);
that returns (creating if necessary) the BorderImages*. Move the instance
specific state into the constructor and don't inline the constructor.

[koz (OOO until 15th September), 2011/11/15 06:35:43]

Done.

 }
 
 BubbleBorder::~BubbleBorder() {}
 
 void BubbleBorder::Paint(const views::View& view, gfx::Canvas* canvas) const {
   // Convenience shorthand variables.
   const int tl_width = top_left_->width();
   const int tl_height = top_left_->height();
   const int t_height = top_->height();
   const int tr_width = top_right_->width();
@@ skipping 232 matching lines @@
   gfx::Rect bounds(view->GetContentsBounds());
   SkRect rect;
   rect.set(SkIntToScalar(bounds.x()), SkIntToScalar(bounds.y()),
            SkIntToScalar(bounds.right()), SkIntToScalar(bounds.bottom()));
   SkScalar radius = SkIntToScalar(BubbleBorder::GetCornerRadius());
   path.addRoundRect(rect, radius, radius);
   canvas->GetSkCanvas()->drawPath(path, paint);
 }
 
 }  // namespace views