Support creating progress bar notification for Windows

ui/views/controls/progress_bar.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/controls/progress_bar.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 165 matching lines @@
   *tooltip = tooltip_text_;
   return !tooltip_text_.empty();
 }
 
 void ProgressBar::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_PROGRESSBAR;
   state->state = ui::AccessibilityTypes::STATE_READONLY;
 }
 
 gfx::Size ProgressBar::GetPreferredSize() {
-  return gfx::Size(100, 11);
+  gfx::Size pref_size(100, 11);
+  gfx::Insets insets = GetInsets();
+  pref_size.Enlarge(insets.width(), insets.height());
+  return pref_size;
 }
 
 const char* ProgressBar::GetClassName() const {
   return kViewClassName;
 }
 
 void ProgressBar::OnPaint(gfx::Canvas* canvas) {
+  gfx::Insets insets = GetInsets();
+  int bar_left = insets.left();

[sky, 2013/07/15 19:52:41]

GetContentBounds() takes care of insets for you.

[jianli, 2013/07/23 19:04:53]

Done.

+  int bar_top = insets.top();
+  int bar_width = width() - insets.width();
+  int bar_height = height() - insets.height();
+
   const int progress_width =
-      static_cast<int>(width() * GetNormalizedValue() + 0.5);
+      static_cast<int>(bar_width * GetNormalizedValue() + 0.5);
 
   // Draw background.
   FillRoundRect(canvas,
-                0, 0, width(), height(),
+                bar_left, bar_top, bar_width, bar_height,
                 kCornerRadius,
                 kBackgroundColor, kBackgroundColor,
                 false);
   StrokeRoundRect(canvas,
-                  0, 0,
-                  width(), height(),
+                  bar_left, bar_top,
+                  bar_width, bar_height,
                   kCornerRadius,
                   kBackgroundBorderColor,
                   kBorderWidth);
 
   if (progress_width > 1) {
     // Draw inner if wide enough.
     if (progress_width > kBorderWidth * 2) {
       canvas->Save();
 
       SkPath inner_path;
       AddRoundRectPathWithPadding(
-          0, 0, progress_width, height(),
+          bar_left, bar_top, progress_width, bar_height,
           kCornerRadius,
           0,
           &inner_path);
       canvas->ClipPath(inner_path);
 
       const SkColor bar_colors[] = {
         kBarTopColor,
         kBarTopColor,
         kBarColorStart,
         kBarColorEnd,
         kBarColorEnd,
       };
       // We want a thin 1-pixel line for kBarTopColor.
-      SkScalar scalar_height = SkIntToScalar(height());
+      SkScalar scalar_height = SkIntToScalar(bar_height);
       SkScalar highlight_width = SkScalarDiv(SK_Scalar1, scalar_height);
       SkScalar border_width = SkScalarDiv(SkIntToScalar(kBorderWidth),
                                           scalar_height);
       const SkScalar bar_points[] = {
         0,
         border_width,
         border_width + highlight_width,
         SK_Scalar1 - border_width,
         SK_Scalar1,
       };
 
       const SkColor disabled_bar_colors[] = {
         kDisabledBarColorStart,
         kDisabledBarColorStart,
         kDisabledBarColorEnd,
         kDisabledBarColorEnd,
       };
 
       const SkScalar disabled_bar_points[] = {
         0,
         border_width,
         SK_Scalar1 - border_width,
         SK_Scalar1
       };
 
       // Do not start from (kBorderWidth, kBorderWidth) because it makes gaps
       // between the inner and the border.
       FillRoundRect(canvas,
-                    0, 0,
-                    progress_width, height(),
+                    bar_left, bar_top,
+                    progress_width, bar_height,
                     kCornerRadius,
                     enabled() ? bar_colors : disabled_bar_colors,
                     enabled() ? bar_points : disabled_bar_points,
                     enabled() ? arraysize(bar_colors) :
                         arraysize(disabled_bar_colors),
                     false);
 
       if (enabled()) {
         // Draw the highlight to the right.
         const SkColor highlight_colors[] = {
@@ skipping 15 matching lines @@
             std::max(0, progress_width - kHighlightWidth - kBorderWidth);
         p[0].iset(highlight_left, 0);
         p[1].iset(progress_width, 0);
         skia::RefPtr<SkShader> s =
             skia::AdoptRef(SkGradientShader::CreateLinear(
                 p, highlight_colors, highlight_points,
                 arraysize(highlight_colors), SkShader::kClamp_TileMode, NULL));
         paint.setShader(s.get());
         paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
         canvas->DrawRect(gfx::Rect(highlight_left, 0,
-                                   kHighlightWidth + kBorderWidth, height()),
+                                   kHighlightWidth + kBorderWidth, bar_height),
                          paint);
       }
 
       canvas->Restore();
     }
 
     // Draw bar stroke
     StrokeRoundRect(canvas,
-                    0, 0, progress_width, height(),
+                    bar_left, bar_top, progress_width, bar_height,
                     kCornerRadius,
                     enabled() ? kBarBorderColor : kDisabledBarBorderColor,
                     kBorderWidth);
   }
 }
 
 }  // namespace views