Add progress notification support to new-style notification.

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 <cmath>
 #include <string>
 
@@ skipping 10 matching lines @@
 
 namespace views {
 
 namespace {
 
 // In DP, the amount to round the corners of the progress bar (both bg and
 // fg, aka slice).
 const int kCornerRadius = 3;
 
 // Adds a rectangle to the path. The corners will be rounded if there is room.
-void AddPossiblyRoundRectToPath(const gfx::Rect& rectangle, SkPath* path) {
-  if (rectangle.height() < kCornerRadius) {
+void AddPossiblyRoundRectToPath(const gfx::Rect& rectangle,
+                                bool allow_round_corner,
+                                SkPath* path) {
+  if (!allow_round_corner || rectangle.height() < kCornerRadius) {
     path->addRect(gfx::RectToSkRect(rectangle));
   } else {
     path->addRoundRect(gfx::RectToSkRect(rectangle), kCornerRadius,
                        kCornerRadius);
   }
 }
 
 }  // namespace
 
 // static
 const char ProgressBar::kViewClassName[] = "ProgressBar";
 
-ProgressBar::ProgressBar(int preferred_height)
-    : preferred_height_(preferred_height) {
+ProgressBar::ProgressBar(int preferred_height, bool allow_round_corner)
+    : preferred_height_(preferred_height),
+      allow_round_corner_(allow_round_corner) {
   EnableCanvasFlippingForRTLUI(true);
 }
 
 ProgressBar::~ProgressBar() {
 }
 
 void ProgressBar::GetAccessibleNodeData(ui::AXNodeData* node_data) {
   node_data->role = ui::AX_ROLE_PROGRESS_INDICATOR;
   node_data->AddState(ui::AX_STATE_READ_ONLY);
 }
@@ skipping 11 matching lines @@
 }
 
 void ProgressBar::OnPaint(gfx::Canvas* canvas) {
   if (IsIndeterminate())
     return OnPaintIndeterminate(canvas);
 
   gfx::Rect content_bounds = GetContentsBounds();
 
   // Draw background.
   SkPath background_path;
-  AddPossiblyRoundRectToPath(content_bounds, &background_path);
+  AddPossiblyRoundRectToPath(content_bounds, allow_round_corner_,
+                             &background_path);
   cc::PaintFlags background_flags;
   background_flags.setStyle(cc::PaintFlags::kFill_Style);
   background_flags.setAntiAlias(true);
   background_flags.setColor(GetBackgroundColor());
   canvas->DrawPath(background_path, background_flags);
 
   // Draw slice.
   SkPath slice_path;
   const int slice_width = static_cast<int>(
       content_bounds.width() * std::min(current_value_, 1.0) + 0.5);
   if (slice_width < 1)
     return;
 
   gfx::Rect slice_bounds = content_bounds;
   slice_bounds.set_width(slice_width);
-  AddPossiblyRoundRectToPath(slice_bounds, &slice_path);
+  AddPossiblyRoundRectToPath(slice_bounds, allow_round_corner_, &slice_path);
 
   cc::PaintFlags slice_flags;
   slice_flags.setStyle(cc::PaintFlags::kFill_Style);
   slice_flags.setAntiAlias(true);
   slice_flags.setColor(GetForegroundColor());
   canvas->DrawPath(slice_path, slice_flags);
 }
 
 void ProgressBar::SetValue(double value) {
   double adjusted_value = (value < 0.0 || value > 1.0) ? -1.0 : value;
@@ skipping 38 matching lines @@
 
 bool ProgressBar::IsIndeterminate() {
   return current_value_ < 0.0;
 }
 
 void ProgressBar::OnPaintIndeterminate(gfx::Canvas* canvas) {
   gfx::Rect content_bounds = GetContentsBounds();
 
   // Draw background.
   SkPath background_path;
-  AddPossiblyRoundRectToPath(content_bounds, &background_path);
+  AddPossiblyRoundRectToPath(content_bounds, allow_round_corner_,
+                             &background_path);
   cc::PaintFlags background_flags;
   background_flags.setStyle(cc::PaintFlags::kFill_Style);
   background_flags.setAntiAlias(true);
   background_flags.setColor(GetBackgroundColor());
   canvas->DrawPath(background_path, background_flags);
 
   // Draw slice.
   SkPath slice_path;
   double time = indeterminate_bar_animation_->GetCurrentValue();
 
@@ skipping 23 matching lines @@
   int bar1_start_x = std::round(content_bounds.width() * bar1_left);
   int bar1_end_x = std::round(
       content_bounds.width() * std::min(1.0, bar1_left + bar1_width));
   int bar2_start_x = std::round(content_bounds.width() * bar2_left);
   int bar2_end_x = std::round(
       content_bounds.width() * std::min(1.0, bar2_left + bar2_width));
 
   gfx::Rect slice_bounds = content_bounds;
   slice_bounds.set_x(content_bounds.x() + bar1_start_x);
   slice_bounds.set_width(bar1_end_x - bar1_start_x);
-  AddPossiblyRoundRectToPath(slice_bounds, &slice_path);
+  AddPossiblyRoundRectToPath(slice_bounds, allow_round_corner_, &slice_path);
   slice_bounds.set_x(content_bounds.x() + bar2_start_x);
   slice_bounds.set_width(bar2_end_x - bar2_start_x);
-  AddPossiblyRoundRectToPath(slice_bounds, &slice_path);
+  AddPossiblyRoundRectToPath(slice_bounds, allow_round_corner_, &slice_path);
 
   cc::PaintFlags slice_flags;
   slice_flags.setStyle(cc::PaintFlags::kFill_Style);
   slice_flags.setAntiAlias(true);
   slice_flags.setColor(GetForegroundColor());
   canvas->DrawPath(slice_path, slice_flags);
 }
 
 }  // namespace views