Add progress notification support to new-style notification.

ui/message_center/views/notification_view_md.cc

 // Copyright 2017 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_md.h"
 
 #include <stddef.h>
 
 #include "base/strings/string_util.h"
 #include "ui/base/cursor/cursor.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/message_center_style.h"
 #include "ui/message_center/notification.h"
 #include "ui/message_center/notification_types.h"
 #include "ui/message_center/vector_icons.h"
 #include "ui/message_center/views/bounded_label.h"
 #include "ui/message_center/views/constants.h"
 #include "ui/message_center/views/message_center_controller.h"
 #include "ui/message_center/views/notification_header_view.h"
 #include "ui/message_center/views/padded_button.h"
 #include "ui/message_center/views/proportional_image_view.h"
 #include "ui/strings/grit/ui_strings.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
+#include "ui/views/controls/progress_bar.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/native_cursor.h"
 #include "ui/views/view_targeter.h"
 #include "ui/views/widget/widget.h"
 
 namespace message_center {
 
 namespace {
 
 // Dimensions.
 constexpr gfx::Insets kContentRowPadding(4, 12, 12, 12);
 constexpr gfx::Insets kActionsRowPadding(8, 8, 8, 8);
 constexpr int kActionsRowHorizontalSpacing = 8;
 constexpr gfx::Insets kImageContainerPadding(0, 12, 12, 12);
 
 // Foreground of small icon image.
 constexpr SkColor kSmallImageBackgroundColor = SK_ColorWHITE;
 // Background of small icon image.
 const SkColor kSmallImageColor = SkColorSetRGB(0x43, 0x43, 0x43);
 // Background of inline actions area.
 const SkColor kActionsRowBackgroundColor = SkColorSetRGB(0xee, 0xee, 0xee);
 
 // Max number of lines for message_view_.
 constexpr int kMaxLinesForMessageView = 1;
 constexpr int kMaxLinesForExpandedMessageView = 4;
 
+constexpr int kCompactTitleMessageViewSpacing = 12;
+
+constexpr int kProgressBarHeight = 4;
+
 const gfx::ImageSkia CreateSolidColorImage(int width,
                                            int height,
                                            SkColor color) {
   SkBitmap bitmap;
   bitmap.allocN32Pixels(width, height);
   bitmap.eraseColor(color);
   return gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
 }
 
 // Take the alpha channel of icon, mask it with the foreground,
@@ skipping 46 matching lines @@
   views::Label* message = new views::Label(item.message);
   message->set_collapse_when_hidden(true);
   message->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   message->SetEnabledColor(message_center::kDimTextColor);
   message->SetBackgroundColor(message_center::kDimTextBackgroundColor);
   AddChildView(message);
 }
 
 ItemView::~ItemView() {}
 
+// CompactTitleMessageView /////////////////////////////////////////////////////
+
+// CompactTitleMessageView shows notification title and message in a single
+// line. This view is used for NOTIFICATION_TYPE_PROGRESS.
+class CompactTitleMessageView : public views::View {
+ public:
+  explicit CompactTitleMessageView();
+  ~CompactTitleMessageView() override;
+
+  void OnPaint(gfx::Canvas* canvas) override;
+
+  void set_title(const base::string16& title) { title_ = title; }
+  void set_message(const base::string16& message) { message_ = message; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CompactTitleMessageView);
+
+  base::string16 title_;
+  base::string16 message_;
+
+  views::Label* title_view_ = nullptr;
+  views::Label* message_view_ = nullptr;
+};
+
+CompactTitleMessageView::~CompactTitleMessageView() {}
+
+CompactTitleMessageView::CompactTitleMessageView() {
+  SetLayoutManager(new views::FillLayout());
+
+  const gfx::FontList& font_list = views::Label().font_list().Derive(
+      1, gfx::Font::NORMAL, gfx::Font::Weight::NORMAL);
+
+  title_view_ = new views::Label();
+  title_view_->SetFontList(font_list);
+  title_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  title_view_->SetEnabledColor(message_center::kRegularTextColor);
+  AddChildView(title_view_);
+
+  message_view_ = new views::Label();
+  message_view_->SetFontList(font_list);
+  message_view_->SetHorizontalAlignment(gfx::ALIGN_RIGHT);
+  message_view_->SetEnabledColor(message_center::kDimTextColor);
+  AddChildView(message_view_);
+}
+
+void CompactTitleMessageView::OnPaint(gfx::Canvas* canvas) {
+  base::string16 title = title_;
+  base::string16 message = message_;
+
+  const gfx::FontList& font_list = views::Label().font_list().Derive(
+      1, gfx::Font::NORMAL, gfx::Font::Weight::NORMAL);
+
+  // Elides title and message. The behavior is based on Android's one.
+  // * If the title is too long, only the title is shown.
+  // * If the message is too long, the full content of the title is shown,
+  //   kCompactTitleMessageViewSpacing is added between them, and the elided
+  //   message is shown.
+  // * If they are short enough, the title is left-aligned and the message is
+  //   right-aligned.
+  const int original_title_width =
+      gfx::Canvas::GetStringWidthF(title, font_list);
+  if (original_title_width >= width())
+    message.clear();
+  title = gfx::ElideText(title, font_list, width(), gfx::ELIDE_TAIL);
+  const int title_width = gfx::Canvas::GetStringWidthF(title, font_list);
+  const int message_width =
+      std::max(0, width() - title_width - kCompactTitleMessageViewSpacing);
+  message = gfx::ElideText(message, font_list, message_width, gfx::ELIDE_TAIL);
+
+  title_view_->SetText(title);
+  message_view_->SetText(message);
+
+  views::View::OnPaint(canvas);
+}
+
 }  // anonymous namespace
 
 // ////////////////////////////////////////////////////////////
 // NotificationViewMD
 // ////////////////////////////////////////////////////////////
 
 views::View* NotificationViewMD::TargetForRect(views::View* root,
                                                const gfx::Rect& rect) {
   CHECK_EQ(root, this);
 
@@ skipping 18 matching lines @@
     gfx::Point point_in_child = point;
     ConvertPointToTarget(this, buttons[i], &point_in_child);
     if (buttons[i]->HitTestPoint(point_in_child))
       return buttons[i]->GetEventHandlerForPoint(point_in_child);
   }
 
   return root;
 }
 
 void NotificationViewMD::CreateOrUpdateViews(const Notification& notification) {
+  right_content_->SetVisible(notification.type() !=

[fukino, 2017/06/22 00:27:10]

I think you can check the notification type in CreateOrUpdateIconView() and
determine if the notification icon should be added or not. (I assume we don't
need to change the visibility of right_content_ when notification icon is not
added.)

[tetsui, 2017/06/22 02:09:23]

Done.

+                                 NOTIFICATION_TYPE_PROGRESS &&
+                             notification.type() != NOTIFICATION_TYPE_MULTIPLE);
   CreateOrUpdateContextTitleView(notification);
   CreateOrUpdateTitleView(notification);
   CreateOrUpdateMessageView(notification);
+  CreateOrUpdateCompactTitleMessageView(notification);
   CreateOrUpdateProgressBarView(notification);
   CreateOrUpdateListItemViews(notification);
   CreateOrUpdateIconView(notification);
   CreateOrUpdateSmallIconView(notification);
   CreateOrUpdateImageView(notification);
   CreateOrUpdateActionButtonViews(notification);
   CreateOrUpdateCloseButtonView(notification);
   CreateOrUpdateSettingsButtonView(notification);
   UpdateViewForExpandedState(expanded_);
 }
@@ skipping 153 matching lines @@
     header_row_->close_button()->RequestFocus();
 }
 
 void NotificationViewMD::CreateOrUpdateContextTitleView(
     const Notification& notification) {
   header_row_->SetAppName(notification.display_source());
 }
 
 void NotificationViewMD::CreateOrUpdateTitleView(
     const Notification& notification) {
+  if (notification.type() == NOTIFICATION_TYPE_PROGRESS) {
+    left_content_->RemoveChildView(title_view_);
+    title_view_ = nullptr;
+    return;
+  }
   const gfx::FontList& font_list = views::Label().font_list().Derive(
       1, gfx::Font::NORMAL, gfx::Font::Weight::NORMAL);
 
   int title_character_limit =
       kNotificationWidth * kMaxTitleLines / kMinPixelsPerTitleCharacter;
 
   base::string16 title = gfx::TruncateString(
       notification.title(), title_character_limit, gfx::WORD_BREAK);
   if (!title_view_) {
     title_view_ = new views::Label(title);
     title_view_->SetFontList(font_list);
     title_view_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
     title_view_->SetEnabledColor(message_center::kRegularTextColor);
     left_content_->AddChildView(title_view_);
   } else {
     title_view_->SetText(title);
   }
 }
 
 void NotificationViewMD::CreateOrUpdateMessageView(
     const Notification& notification) {
-  if (notification.message().empty()) {
-    // Deletion will also remove |context_message_view_| from its parent.
+  if (notification.type() == NOTIFICATION_TYPE_PROGRESS ||
+      notification.message().empty()) {
+    // Deletion will also remove |message_view_| from its parent.
     delete message_view_;
     message_view_ = nullptr;
     return;
   }
 
   base::string16 text = gfx::TruncateString(
       notification.message(), kMessageCharacterLimit, gfx::WORD_BREAK);
 
   const gfx::FontList& font_list = views::Label().font_list().Derive(
       1, gfx::Font::NORMAL, gfx::Font::Weight::NORMAL);
 
   if (!message_view_) {
     message_view_ = new BoundedLabel(text, font_list);
     message_view_->SetLineLimit(kMaxLinesForMessageView);
     message_view_->SetColors(message_center::kDimTextColor,
                              kContextTextBackgroundColor);
     left_content_->AddChildView(message_view_);
   } else {
     message_view_->SetText(text);
   }
 
   message_view_->SetVisible(notification.items().empty());
 }
 
+void NotificationViewMD::CreateOrUpdateCompactTitleMessageView(
+    const Notification& notification) {
+  if (notification.type() != NOTIFICATION_TYPE_PROGRESS) {
+    left_content_->RemoveChildView(compact_title_message_view_);
+    compact_title_message_view_ = nullptr;
+    return;
+  }
+  if (!compact_title_message_view_) {
+    compact_title_message_view_ = new CompactTitleMessageView();
+    left_content_->AddChildView(compact_title_message_view_);
+  }
+
+  compact_title_message_view_->set_title(notification.title());
+  compact_title_message_view_->set_message(notification.message());
+  left_content_->InvalidateLayout();
+}
+
 void NotificationViewMD::CreateOrUpdateProgressBarView(
     const Notification& notification) {
-  // TODO(yoshiki): Implement this.
+  if (notification.type() != NOTIFICATION_TYPE_PROGRESS) {
+    left_content_->RemoveChildView(progress_bar_view_);
+    progress_bar_view_ = nullptr;
+    return;
+  }
+
+  DCHECK(left_content_);
+
+  if (!progress_bar_view_) {
+    progress_bar_view_ = new views::ProgressBar(kProgressBarHeight,
+                                                /* allow_round_corner */ false);
+    progress_bar_view_->SetBorder(views::CreateEmptyBorder(
+        message_center::kProgressBarTopPadding, 0, 0, 0));
+    left_content_->AddChildView(progress_bar_view_);
+  }
+
+  progress_bar_view_->SetValue(notification.progress() / 100.0);
+  progress_bar_view_->SetVisible(notification.items().empty());
 }
 
 void NotificationViewMD::CreateOrUpdateListItemViews(
     const Notification& notification) {
   for (auto* item_view : item_views_)
     delete item_view;
   item_views_.clear();
 
   const std::vector<NotificationItem>& items = notification.items();
 
@@ skipping 178 matching lines @@
                                   header_row_->expand_button()->HasFocus()) ||
                                  (header_row_->IsCloseButtonEnabled() &&
                                   header_row_->close_button()->HasFocus()) ||
                                  (header_row_->IsSettingsButtonEnabled() &&
                                   header_row_->settings_button()->HasFocus());
 
   header_row_->SetControlButtonsVisible(target_visibility);
 }
 
 }  // namespace message_center