MacViews: For "NO_ASSET" MD bubbles, just use the border drawn by the window server.

ui/views/bubble/bubble_border.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 "ui/views/bubble/bubble_border.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkDrawLooper.h"
@@ skipping 345 matching lines @@
   canvas->Save();
   canvas->ClipRect(arrow_bounds, SkRegion::kDifference_Op);
   Painter::PaintPainterAt(canvas, images_->border_painter.get(), bounds);
   canvas->Restore();
 
   DrawArrow(canvas, arrow_bounds);
 }
 
 gfx::Insets BubbleBorder::GetInsets() const {
   if (UseMd()) {
-     gfx::Insets blur(kLargeShadowBlur);
-     gfx::Insets offset(-kLargeShadowVerticalOffset, 0,
-                        kLargeShadowVerticalOffset, 0);
-     gfx::Insets border(kBorderThicknessDip);
-     return blur + offset;
+    if (shadow_ == NO_ASSETS)
+      return gfx::Insets();
+
+    gfx::Insets blur(kLargeShadowBlur);
+    gfx::Insets offset(-kLargeShadowVerticalOffset, 0,
+                       kLargeShadowVerticalOffset, 0);
+    gfx::Insets border(kBorderThicknessDip);
+    return blur + offset;
   }
 
   // The insets contain the stroke and shadow pixels outside the bubble fill.
   const int inset = GetBorderThickness();
   if (arrow_paint_type_ != PAINT_NORMAL || !has_arrow(arrow_))
     return gfx::Insets(inset);
 
   int first_inset = inset;
   int second_inset = std::max(inset, images_->arrow_thickness);
   if (is_arrow_on_horizontal(arrow_) ?
@@ skipping 117 matching lines @@
   canvas->DrawImageInt(*GetArrowImage(), arrow_bounds.x(), arrow_bounds.y());
   SkPath path;
   GetArrowPathFromArrowBounds(arrow_bounds, &path);
   SkPaint paint;
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(background_color_);
 
   canvas->DrawPath(path, paint);
 }
 
+SkRRect BubbleBorder::GetClientRect(const View& view) const {
+  gfx::RectF bounds(view.GetLocalBounds());
+  bounds.Inset(GetInsets());
+  return SkRRect::MakeRectXY(gfx::RectFToSkRect(bounds),
+                             GetBorderCornerRadius(), GetBorderCornerRadius());
+}
+
 void BubbleBorder::PaintMd(const View& view, gfx::Canvas* canvas) {
+  if (shadow_ == NO_ASSETS)
+    return PaintNoAssets(view, canvas);
+
   gfx::ScopedCanvas scoped(canvas);
 
   SkPaint paint;
   std::vector<gfx::ShadowValue> shadows;
   // gfx::ShadowValue counts blur pixels both inside and outside the shape,
   // whereas these blur values only describe the outside portion, hence they
   // must be doubled.
   shadows.emplace_back(gfx::Vector2d(0, kSmallShadowVerticalOffset),
                        2 * kSmallShadowBlur, kSmallShadowColor);
   shadows.emplace_back(gfx::Vector2d(0, kLargeShadowVerticalOffset),
                        2 * kLargeShadowBlur, kLargeShadowColor);
   paint.setLooper(gfx::CreateShadowDrawLooperCorrectBlur(shadows));
   paint.setColor(SkColorSetA(SK_ColorBLACK, 0x26));
   paint.setAntiAlias(true);
 
-  gfx::RectF bounds(view.GetLocalBounds());
-  bounds.Inset(GetInsets());
-  // Clip out a round rect so the fill and shadow don't draw over the contents
-  // of the bubble.
-  SkRRect clip_r_rect =
-      SkRRect::MakeRectXY(gfx::RectFToSkRect(bounds), GetBorderCornerRadius(),
-                          GetBorderCornerRadius());
-  canvas->sk_canvas()->clipRRect(clip_r_rect, SkRegion::kDifference_Op,
+  SkRRect r_rect = GetClientRect(view);
+  canvas->sk_canvas()->clipRRect(r_rect, SkRegion::kDifference_Op,
                                  true /*doAntiAlias*/);
 
   // The border is drawn outside the content area.
-  SkRRect r_rect = clip_r_rect;
   const SkScalar one_pixel =
       SkFloatToScalar(kBorderStrokeThicknessPx / canvas->image_scale());
   r_rect.inset(-one_pixel, -one_pixel);
   canvas->sk_canvas()->drawRRect(r_rect, paint);
 }
 
+void BubbleBorder::PaintNoAssets(const View& view, gfx::Canvas* canvas) {
+  gfx::ScopedCanvas scoped(canvas);
+  canvas->sk_canvas()->clipRRect(GetClientRect(view), SkRegion::kDifference_Op,
+                                 true /*doAntiAlias*/);
+  canvas->sk_canvas()->drawColor(SK_ColorTRANSPARENT, SkBlendMode::kSrc);
+}
+
 internal::BorderImages* BubbleBorder::GetImagesForTest() const {
   return images_;
 }
 
 void BubbleBackground::Paint(gfx::Canvas* canvas, views::View* view) const {
   if (border_->shadow() == BubbleBorder::NO_SHADOW_OPAQUE_BORDER)
     canvas->DrawColor(border_->background_color());
 
   // Fill the contents with a round-rect region to match the border images.
   SkPaint paint;
   paint.setAntiAlias(true);
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(border_->background_color());
   SkPath path;
   gfx::RectF bounds(view->GetLocalBounds());
   bounds.Inset(gfx::InsetsF(border_->GetInsets()));
 
   canvas->DrawRoundRect(bounds, border_->GetBorderCornerRadius(), paint);
 }
 
 }  // namespace views