Implement new-style image notification resizing.

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"
@@ skipping 31 matching lines @@
 #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);
 constexpr gfx::Insets kActionButtonPadding(0, 12, 0, 12);
 constexpr gfx::Size kActionButtonMinSize(88, 32);
+constexpr gfx::Insets kLargeImageContainerPadding(0, 12, 12, 12);
+constexpr gfx::Size kLargeImageMinSize(328, 0);
+constexpr gfx::Size kLargeImageMaxSize(328, 218);

[tetsui, 2017/07/03 03:51:25]

In new-style notification mock, the notification width is 352dp while it is
360dp in old-style. So the layout is slightly broken.
This can be easily fixed by setting kNotificationWidth = 352 in
message_center_style.h.

 
 // 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);
 // Base ink drop color of action buttons.
 const SkColor kActionButtonInkDropBaseColor = SkColorSetRGB(0x0, 0x0, 0x0);
 // Ripple ink drop opacity of action buttons.
 const float kActionButtonInkDropRippleVisibleOpacity = 0.08f;
 // Highlight (hover) ink drop opacity of action buttons.
 const float kActionButtonInkDropHighlightVisibleOpacity = 0.08f;
 // Text color of action button.
 const SkColor kActionButtonTextColor = SkColorSetRGB(0x33, 0x67, 0xD6);
+// Background color of the large image.
+const SkColor kLargeImageBackgroundColor = SkColorSetRGB(0xf5, 0xf5, 0xf5);
 
 // Max number of lines for message_view_.
 constexpr int kMaxLinesForMessageView = 1;
 constexpr int kMaxLinesForExpandedMessageView = 4;
 
 constexpr int kListNotificationOverflowIndicatorSpacing = 4;
 constexpr int kCompactTitleMessageViewSpacing = 12;
 
 constexpr int kProgressBarHeight = 4;
 
@@ skipping 225 matching lines @@
 NotificationButtonMD::~NotificationButtonMD() = default;
 
 std::unique_ptr<views::InkDropHighlight>
 NotificationButtonMD::CreateInkDropHighlight() const {
   std::unique_ptr<views::InkDropHighlight> highlight =
       views::LabelButton::CreateInkDropHighlight();
   highlight->set_visible_opacity(kActionButtonInkDropHighlightVisibleOpacity);
   return highlight;
 }
 
+// LargeImageView //////////////////////////////////////////////////////////////
+
+class LargeImageView : public views::View {
+ public:
+  explicit LargeImageView();
+  ~LargeImageView() override;
+
+  void SetImage(const gfx::ImageSkia& image);
+
+  void OnPaint(gfx::Canvas* canvas) override;
+  const char* GetClassName() const override;
+
+  views::View* container() { return container_; }
+
+ private:
+  gfx::Size GetResizedImageSize();
+
+  views::View* container_ = nullptr;

[yoshiki, 2017/07/28 06:13:03]

nit: please add a comment about how the container works. It looks not obvious.
If you think necessary, please add a reference to the mock.

[tetsui, 2017/07/28 06:38:45]

Done.

+  gfx::ImageSkia image_;
+};

[yoshiki, 2017/07/28 06:13:03]

Please add DISALLOW_COPY_AND_ASSIGN. This class should be non-copyable.

[tetsui, 2017/07/28 06:38:45]

Done.

+
+LargeImageView::LargeImageView() {
+  SetBackground(views::CreateSolidBackground(kLargeImageBackgroundColor));
+  container_ = new views::View;
+  container_->SetLayoutManager(new views::FillLayout());
+  container_->SetBorder(views::CreateEmptyBorder(kLargeImageContainerPadding));
+  container_->SetBackground(
+      views::CreateSolidBackground(message_center::kImageBackgroundColor));
+  container_->AddChildView(this);
+}
+
+LargeImageView::~LargeImageView() = default;
+
+void LargeImageView::SetImage(const gfx::ImageSkia& image) {
+  image_ = image;
+  gfx::Size preferred_size = GetResizedImageSize();
+  preferred_size.SetToMax(kLargeImageMinSize);
+  preferred_size.SetToMin(kLargeImageMaxSize);
+  SetPreferredSize(preferred_size);
+  SchedulePaint();
+  Layout();
+}
+
+void LargeImageView::OnPaint(gfx::Canvas* canvas) {
+  views::View::OnPaint(canvas);
+
+  gfx::Size resized_size = GetResizedImageSize();
+  gfx::Size drawn_size = resized_size;
+  drawn_size.SetToMin(kLargeImageMaxSize);
+  gfx::Rect drawn_bounds = GetContentsBounds();
+  drawn_bounds.ClampToCenteredSize(drawn_size);
+
+  gfx::ImageSkia resized_image = gfx::ImageSkiaOperations::CreateResizedImage(
+      image_, skia::ImageOperations::RESIZE_BEST, resized_size);
+
+  // Cut off the overflown part.
+  gfx::ImageSkia drawn_image = gfx::ImageSkiaOperations::ExtractSubset(
+      resized_image, gfx::Rect(drawn_size));
+
+  canvas->DrawImageInt(drawn_image, drawn_bounds.x(), drawn_bounds.y());
+}
+
+const char* LargeImageView::GetClassName() const {
+  return "LargeImageView";
+}
+
+// Returns expected size of the image right after resizing.
+// The GetResizedImageSize().width() <= kLargeImageMaxSize.width() holds, but
+// GetResizedImageSize().height() may be larger than kLargeImageMaxSize.height()
+// In this case, the overflown part will be just cutted off from the view.
+gfx::Size LargeImageView::GetResizedImageSize() {
+  gfx::Size original_size = image_.size();
+  if (original_size.width() <= kLargeImageMaxSize.width()) {
+    return image_.size();
+  } else {

[yoshiki, 2017/07/28 06:13:03]

optional: I prefer the following style since this if-block is a kind of
short-circuit. But it's up to you.

if (...) {
  return ...;
}

xxx;

[tetsui, 2017/07/28 06:38:45]

Done.

+    const double proportion =
+        original_size.height() / static_cast<double>(original_size.width());
+    gfx::Size resized_size;
+    resized_size.SetSize(kLargeImageMaxSize.width(),
+                         kLargeImageMaxSize.width() * proportion);
+    return resized_size;
+  }
+}
+
 }  // anonymous namespace
 
 // ////////////////////////////////////////////////////////////
 // NotificationViewMD
 // ////////////////////////////////////////////////////////////
 
 views::View* NotificationViewMD::TargetForRect(views::View* root,
                                                const gfx::Rect& rect) {
   CHECK_EQ(root, this);
 
@@ skipping 317 matching lines @@
     item_views_.back()->SetRemainingCount(items.size() - item_views_.size());
 
     // Needed when CreateOrUpdateViews is called for update.
     left_content_->InvalidateLayout();
   }
 }
 
 void NotificationViewMD::CreateOrUpdateIconView(
     const Notification& notification) {
   if (notification.type() == NOTIFICATION_TYPE_PROGRESS ||
-      notification.type() == NOTIFICATION_TYPE_MULTIPLE) {
+      notification.type() == NOTIFICATION_TYPE_MULTIPLE ||
+      notification.type() == NOTIFICATION_TYPE_IMAGE) {
     right_content_->RemoveChildView(icon_view_);
     icon_view_ = nullptr;
     return;
   }
 
   gfx::Size image_view_size(30, 30);
   if (!icon_view_) {
     icon_view_ = new ProportionalImageView(image_view_size);
     right_content_->AddChildView(icon_view_);
   }
 
   gfx::ImageSkia icon = notification.icon().AsImageSkia();
   icon_view_->SetImage(icon, icon.size());
 }
 
 void NotificationViewMD::CreateOrUpdateSmallIconView(
     const Notification& notification) {
   gfx::ImageSkia icon =
       notification.small_image().IsEmpty()
           ? GetProductIcon()
           : GetMaskedIcon(notification.small_image().AsImageSkia());
   header_row_->SetAppIcon(icon);
 }
 
 void NotificationViewMD::CreateOrUpdateImageView(
     const Notification& notification) {
-  // |image_view_| is the view representing the area covered by the
-  // notification's image, including background and border.  Its size can be
-  // specified in advance and images will be scaled to fit including a border if
-  // necessary.
   if (notification.image().IsEmpty()) {
-    if (image_container_) {
-      DCHECK(image_view_);
-
-      left_content_->RemoveChildView(image_container_);
-      image_container_ = NULL;
-      image_view_ = NULL;
-    } else {
-      DCHECK(!image_view_);
+    if (image_view_) {
+      RemoveChildView(image_view_->container());
+      image_view_ = nullptr;
     }
     return;
   }
 
-  gfx::Size ideal_size(kNotificationPreferredImageWidth,
-                       kNotificationPreferredImageHeight);
-
-  if (!image_container_) {
-    image_container_ = new views::View();
-    image_container_->SetLayoutManager(new views::FillLayout());
-    image_container_->SetBorder(
-        views::CreateEmptyBorder(kImageContainerPadding));
-    image_container_->SetBackground(
-        views::CreateSolidBackground(message_center::kImageBackgroundColor));
-
-    DCHECK(!image_view_);
-    image_view_ = new message_center::ProportionalImageView(ideal_size);
-    image_container_->AddChildView(image_view_);
+  if (!image_view_) {
+    image_view_ = new LargeImageView();
     // Insert the created image container just after the |content_row_|.
-    AddChildViewAt(image_container_, GetIndexOf(content_row_) + 1);
+    AddChildViewAt(image_view_->container(), GetIndexOf(content_row_) + 1);
   }
 
-  DCHECK(image_view_);
-  image_view_->SetImage(notification.image().AsImageSkia(), ideal_size);
+  image_view_->SetImage(notification.image().AsImageSkia());
 }
 
 void NotificationViewMD::CreateOrUpdateActionButtonViews(
     const Notification& notification) {
   std::vector<ButtonInfo> buttons = notification.buttons();
   bool new_buttons = action_buttons_.size() != buttons.size();
 
   if (new_buttons || buttons.size() == 0) {
     for (auto* item : action_buttons_)
       delete item;
@@ skipping 75 matching lines @@
   if (controller())
     controller()->UpdateNotificationSize(notification_id());
 }
 
 void NotificationViewMD::UpdateViewForExpandedState(bool expanded) {
   header_row_->SetExpanded(expanded);
   if (message_view_) {
     message_view_->SetLineLimit(expanded ? kMaxLinesForExpandedMessageView
                                          : kMaxLinesForMessageView);
   }
-  if (image_container_)
-    image_container_->SetVisible(expanded);
+  if (image_view_)
+    image_view_->container()->SetVisible(expanded);
   actions_row_->SetVisible(expanded && actions_row_->has_children());
   for (size_t i = 1; i < item_views_.size(); ++i) {
     item_views_[i]->SetVisible(expanded);
   }
   if (!item_views_.empty()) {
     item_views_.front()->SetRemainingCountVisible(!expanded);
     item_views_.back()->SetRemainingCountVisible(expanded);
   }
 }
 
 void NotificationViewMD::UpdateControlButtonsVisibility() {
   const bool target_visibility = IsMouseHovered() || HasFocus() ||
                                  (header_row_->IsExpandButtonEnabled() &&
                                   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