views: Make View::set_border() take a scoped_ptr<>.

ui/message_center/views/notification_view.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/message_center/views/notification_view.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ui_resources.h"
@@ skipping 36 matching lines @@
 namespace {
 
 // Dimensions.
 const int kProgressBarWidth = message_center::kNotificationWidth -
     message_center::kTextLeftPadding - message_center::kTextRightPadding;
 const int kProgressBarBottomPadding = 0;
 const int kExpandIconBottomPadding = 8;
 const int kExpandIconRightPadding = 11;
 
 // static
-views::Border* MakeEmptyBorder(int top, int left, int bottom, int right) {
+scoped_ptr<views::Border> MakeEmptyBorder(int top,
+                                          int left,
+                                          int bottom,
+                                          int right) {
   return views::Border::CreateEmptyBorder(top, left, bottom, right);
 }
 
 // static
-views::Border* MakeTextBorder(int padding, int top, int bottom) {
+scoped_ptr<views::Border> MakeTextBorder(int padding,
+                                         int top,
+                                         int bottom) {
   // Split the padding between the top and the bottom, then add the extra space.
   return MakeEmptyBorder(padding / 2 + top,
                          message_center::kTextLeftPadding,
                          (padding + 1) / 2 + bottom,
                          message_center::kTextRightPadding);
 }
 
 // static
-views::Border* MakeProgressBarBorder(int top, int bottom) {
+scoped_ptr<views::Border> MakeProgressBarBorder(int top, int bottom) {
   return MakeEmptyBorder(top,
                          message_center::kTextLeftPadding,
                          bottom,
                          message_center::kTextRightPadding);
 }
 
 // static
-views::Border* MakeSeparatorBorder(int top, int left, SkColor color) {
+scoped_ptr<views::Border> MakeSeparatorBorder(int top,
+                                              int left,
+                                              SkColor color) {
   return views::Border::CreateSolidSidedBorder(top, left, 0, 0, color);
 }
 
 // static
 // Return true if and only if the image is null or has alpha.
 bool HasAlpha(gfx::ImageSkia& image, views::Widget* widget) {
   // Determine which bitmap to use.
   ui::ScaleFactor factor = ui::SCALE_FACTOR_100P;
   if (widget) {
     factor = ui::GetScaleFactorForNativeView(widget->GetNativeView());
@@ skipping 85 matching lines @@
   gfx::Size scaled_size =
       message_center::GetImageSizeForContainerSize(ideal_size, image.Size());
 
   views::View* proportional_image_view =
       new message_center::ProportionalImageView(image.AsImageSkia(),
                                                 ideal_size);
 
   // This calculation determines that the new image would have the correct
   // height for width.
   if (ideal_size != scaled_size) {
-    proportional_image_view->set_border(views::Border::CreateSolidBorder(
+    proportional_image_view->SetBorder(views::Border::CreateSolidBorder(
         message_center::kNotificationImageBorderSize, SK_ColorTRANSPARENT));
   }
 
   container->AddChildView(proportional_image_view);
   return container;
 }
 
 // NotificationProgressBar /////////////////////////////////////////////////////
 
 class NotificationProgressBar : public views::ProgressBar {
@@ skipping 108 matching lines @@
       controller_(controller),
       clickable_(notification.clickable()),
       is_expanded_(expanded) {
   std::vector<base::string16> accessible_lines;
   // Create the top_view_, which collects into a vertical box all content
   // at the top of the notification (to the right of the icon) except for the
   // close button.
   top_view_ = new views::View();
   top_view_->SetLayoutManager(
       new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 0));
-  top_view_->set_border(MakeEmptyBorder(
+  top_view_->SetBorder(MakeEmptyBorder(
       kTextTopPadding - 8, 0, kTextBottomPadding - 5, 0));
 
   const gfx::FontList default_label_font_list = views::Label().font_list();
 
   // Create the title view if appropriate.
   title_view_ = NULL;
   if (!notification.title().empty()) {
     const gfx::FontList& font_list =
         default_label_font_list.DeriveFontListWithSizeDelta(2);
     int padding = kTitleLineHeight - font_list.GetHeight();
     title_view_ = new BoundedLabel(
         gfx::TruncateString(notification.title(), kTitleCharacterLimit),
         font_list);
     title_view_->SetLineHeight(kTitleLineHeight);
     title_view_->SetLineLimit(IsExperimentalNotificationUIEnabled() ?
                               message_center::kExperimentalTitleLineLimit :
                               message_center::kTitleLineLimit);
     title_view_->SetColors(message_center::kRegularTextColor,
                            kRegularTextBackgroundColor);
-    title_view_->set_border(MakeTextBorder(padding, 3, 0));
+    title_view_->SetBorder(MakeTextBorder(padding, 3, 0));
     top_view_->AddChildView(title_view_);
     accessible_lines.push_back(notification.title());
   }
 
   // Create the message view if appropriate.
   message_view_ = NULL;
   if (!notification.message().empty()) {
     int padding = kMessageLineHeight - default_label_font_list.GetHeight();
     message_view_ = new BoundedLabel(
         gfx::TruncateString(notification.message(), kMessageCharacterLimit));
     message_view_->SetLineHeight(kMessageLineHeight);
     message_view_->SetVisible(!is_expanded_ || !notification.items().size());
     message_view_->SetColors(message_center::kRegularTextColor,
                              kDimTextBackgroundColor);
-    message_view_->set_border(MakeTextBorder(padding, 4, 0));
+    message_view_->SetBorder(MakeTextBorder(padding, 4, 0));
     top_view_->AddChildView(message_view_);
     accessible_lines.push_back(notification.message());
   }
 
   // Create the context message view if appropriate.
   context_message_view_ = NULL;
   if (!notification.context_message().empty()) {
     int padding = kMessageLineHeight - default_label_font_list.GetHeight();
     context_message_view_ =
         new BoundedLabel(gfx::TruncateString(notification.context_message(),
                                             kContextMessageCharacterLimit),
                          default_label_font_list);
     context_message_view_->SetLineLimit(
         message_center::kContextMessageLineLimit);
     context_message_view_->SetLineHeight(kMessageLineHeight);
     context_message_view_->SetColors(message_center::kDimTextColor,
                                      kContextTextBackgroundColor);
-    context_message_view_->set_border(MakeTextBorder(padding, 4, 0));
+    context_message_view_->SetBorder(MakeTextBorder(padding, 4, 0));
     top_view_->AddChildView(context_message_view_);
     accessible_lines.push_back(notification.context_message());
   }
 
   // Create the progress bar view.
   progress_bar_view_ = NULL;
   if (notification.type() == NOTIFICATION_TYPE_PROGRESS) {
     progress_bar_view_ = new NotificationProgressBar();
-    progress_bar_view_->set_border(MakeProgressBarBorder(
+    progress_bar_view_->SetBorder(MakeProgressBarBorder(
         message_center::kProgressBarTopPadding, kProgressBarBottomPadding));
     progress_bar_view_->SetValue(notification.progress() / 100.0);
     top_view_->AddChildView(progress_bar_view_);
   }
 
   // Create the list item views (up to a maximum).
   int padding = kMessageLineHeight - default_label_font_list.GetHeight();
   std::vector<NotificationItem> items = notification.items();
   for (size_t i = 0; i < items.size() && i < kNotificationMaximumItems; ++i) {
     ItemView* item_view = new ItemView(items[i]);
     item_view->SetVisible(is_expanded_);
-    item_view->set_border(MakeTextBorder(padding, i ? 0 : 4, 0));
+    item_view->SetBorder(MakeTextBorder(padding, i ? 0 : 4, 0));
     item_views_.push_back(item_view);
     top_view_->AddChildView(item_view);
     accessible_lines.push_back(
         items[i].title + base::ASCIIToUTF16(" ") + items[i].message);
   }
 
   // Create the notification icon view.
   gfx::ImageSkia icon = notification.icon().AsImageSkia();
   if (notification.type() == NOTIFICATION_TYPE_SIMPLE &&
       (icon.width() != kIconSize ||
@@ skipping 26 matching lines @@
         kNotificationPreferredImageWidth, kNotificationPreferredImageHeight);
     image_view_ = MakeNotificationImage(notification.image(), image_size);
     image_view_->SetVisible(is_expanded_);
     bottom_view_->AddChildView(image_view_);
   }
 
   // Create action buttons if appropriate.
   std::vector<ButtonInfo> buttons = notification.buttons();
   for (size_t i = 0; i < buttons.size(); ++i) {
     views::View* separator = new views::ImageView();
-    separator->set_border(MakeSeparatorBorder(1, 0, kButtonSeparatorColor));
+    separator->SetBorder(MakeSeparatorBorder(1, 0, kButtonSeparatorColor));
     bottom_view_->AddChildView(separator);
     NotificationButton* button = new NotificationButton(this);
     ButtonInfo button_info = buttons[i];
     button->SetTitle(button_info.title);
     button->SetIcon(button_info.icon.AsImageSkia());
     action_buttons_.push_back(button);
     bottom_view_->AddChildView(button);
   }
 
   // Create expand button
@@ skipping 215 matching lines @@
   return message_view_ ?
          message_view_->GetLinesForWidthAndLimit(width, limit) : 0;
 }
 
 int NotificationView::GetMessageHeight(int width, int limit) {
   return message_view_ ?
          message_view_->GetSizeForWidthAndLines(width, limit).height() : 0;
 }
 
 }  // namespace message_center