[md] Updates aura tooltip colors and padding to MD

ui/views/corewm/tooltip_aura.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 "ui/views/corewm/tooltip_aura.h"
 
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
+#include "ui/base/material_design/material_design_controller.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/render_text.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/gfx/text_utils.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
+#include "ui/views/painter.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace {
 
 // Max visual tooltip width. If a tooltip is greater than this width, it will
 // be wrapped.
 const int kTooltipMaxWidthPixels = 400;
 
+// Corner radius of tooltip background used with Material Design.
+const float kTooltipCornerRadius = 2.f;
+
 // FIXME: get cursor offset from actual cursor size.
 const int kCursorOffsetX = 10;
 const int kCursorOffsetY = 15;
 
 // Creates a widget of type TYPE_TOOLTIP
 views::Widget* CreateTooltipWidget(aura::Window* tooltip_window) {
   views::Widget* widget = new views::Widget;
   views::Widget::InitParams params;
   // For aura, since we set the type to TYPE_TOOLTIP, the widget will get
   // auto-parented to the right container.
   params.type = views::Widget::InitParams::TYPE_TOOLTIP;
   params.context = tooltip_window;
   DCHECK(params.context);
   params.keep_on_top = true;
   params.accept_events = false;
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
+    params.shadow_type = views::Widget::InitParams::SHADOW_TYPE_NONE;
+  }
   widget->Init(params);
   return widget;
 }
 
 }  // namespace
 
 namespace views {
 namespace corewm {
 
 // TODO(oshima): Consider to use views::Label.
 class TooltipAura::TooltipView : public views::View {
  public:
   TooltipView()
       : render_text_(gfx::RenderText::CreateInstance()),
         max_width_(0) {
-    const int kHorizontalPadding = 3;
-    const int kVerticalPadding = 2;
-    SetBorder(Border::CreateEmptyBorder(
-        kVerticalPadding, kHorizontalPadding,
-        kVerticalPadding, kHorizontalPadding));
+    const bool material = ui::MaterialDesignController::IsModeMaterial();
+    const int kHorizontalPadding = material ? 8 : 3;
+    const int kVerticalPaddingTop = material ? 4 : 2;
+    const int kVerticalPaddingBottom = material ? 5 : kVerticalPaddingTop;
+    SetBorder(Border::CreateEmptyBorder(kVerticalPaddingTop, kHorizontalPadding,
+                                        kVerticalPaddingBottom,
+                                        kHorizontalPadding));
 
     set_owned_by_client();
     render_text_->SetWordWrapBehavior(gfx::WRAP_LONG_WORDS);
     render_text_->SetMultiline(true);
 
     ResetDisplayRect();
   }
 
   ~TooltipView() override {}
 
@@ skipping 25 matching lines @@
   void SetText(const base::string16& text) {
     render_text_->SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
     render_text_->SetText(text);
     SchedulePaint();
   }
 
   void SetForegroundColor(SkColor color) {
     render_text_->SetColor(color);
   }
 
+  void SetBackgroundColor(SkColor background_color) {
+    views::Background* background =
+        ui::MaterialDesignController::IsModeMaterial()
+            ? views::Background::CreateBackgroundPainter(
+                  true, views::Painter::CreateSolidRoundRectPainter(
+                            background_color, kTooltipCornerRadius))
+            : views::Background::CreateSolidBackground(background_color);
+    set_background(background);
+    // Force the text color to be readable when |background_color| is not
+    // opaque.
+    render_text_->set_subpixel_rendering_suppressed(
+        SkColorGetA(background_color) != 0xFF);
+  }
+
   void SetMaxWidth(int width) {
     max_width_ = width;
     ResetDisplayRect();
   }
 
  private:
   void ResetDisplayRect() {
     gfx::Insets insets = border()->GetInsets();
     int max_text_width = max_width_ - insets.width();
     render_text_->SetDisplayRect(gfx::Rect(0, 0, max_text_width, 100000));
@@ skipping 61 matching lines @@
 
   if (!widget_) {
     widget_ = CreateTooltipWidget(tooltip_window_);
     widget_->SetContentsView(tooltip_view_.get());
     widget_->AddObserver(this);
   }
 
   SetTooltipBounds(location, tooltip_view_->GetPreferredSize());
 
   ui::NativeTheme* native_theme = widget_->GetNativeTheme();
-  tooltip_view_->set_background(
-      views::Background::CreateSolidBackground(
-          native_theme->GetSystemColor(
-              ui::NativeTheme::kColorId_TooltipBackground)));
+  tooltip_view_->SetBackgroundColor(native_theme->GetSystemColor(
+      ui::NativeTheme::kColorId_TooltipBackground));
   tooltip_view_->SetForegroundColor(native_theme->GetSystemColor(
       ui::NativeTheme::kColorId_TooltipText));
 }
 
 void TooltipAura::Show() {
   if (widget_) {
     widget_->Show();
     widget_->StackAtTop();
   }
 }
 
 void TooltipAura::Hide() {
   tooltip_window_ = NULL;
   if (widget_)
     widget_->Hide();
 }
 
 bool TooltipAura::IsVisible() {
   return widget_ && widget_->IsVisible();
 }
 
 void TooltipAura::OnWidgetDestroying(views::Widget* widget) {
   DCHECK_EQ(widget_, widget);
   widget_ = NULL;
   tooltip_window_ = NULL;
 }
 
 }  // namespace corewm
 }  // namespace views