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/i18n/case_conversion.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"
@@ skipping 17 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::Insets kStatusTextPadding(4, 0, 0, 0);
 constexpr gfx::Size kActionButtonMinSize(88, 32);
 constexpr gfx::Size kIconViewSize(30, 30);
+constexpr gfx::Insets kLargeImageContainerPadding(0, 12, 12, 12);
+constexpr gfx::Size kLargeImageMinSize(328, 0);
+constexpr gfx::Size kLargeImageMaxSize(328, 218);
 
 // 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 kCompactTitleMessageViewSpacing = 12;
 
 constexpr int kProgressBarHeight = 4;
 
 constexpr int kMessageViewWidth =
@@ skipping 170 matching lines @@
 }
 
 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;
+
+  // We have a container view outside LargeImageView, because we want to fill
+  // area that is not coverted by the image by background color.
+  // When adding this view to the parent, add this container instead of the
+  // LargeImageView instance itself.
+  // When removing, just delete the LargeImageView instance.
+  views::View* container() { return container_; }
+
+ private:
+  gfx::Size GetResizedImageSize();
+
+  views::View* const container_;

[Yoshiki IGUCHI, 2017/08/04 07:00:33]

It's not good that a child has a parent. In this implementation, we can't use
LargeImageView directly, instead, we must use container(): it's not standard way
of views.

I think not this class but NotificationViewMD should have a container view. Or
how about creating LargeImageContainerView class which owns LargeImageView? 

[tetsui, 2017/08/04 07:39:31]

Done.

+  gfx::ImageSkia image_;
+
+  DISALLOW_COPY_AND_ASSIGN(LargeImageView);
+};
+
+LargeImageView::LargeImageView() : container_(new views::View) {
+  set_owned_by_client();
+  SetBackground(views::CreateSolidBackground(kLargeImageBackgroundColor));
+  container_->SetLayoutManager(new views::FillLayout());
+  container_->SetBorder(views::CreateEmptyBorder(kLargeImageContainerPadding));
+  container_->SetBackground(
+      views::CreateSolidBackground(message_center::kImageBackgroundColor));
+  container_->AddChildView(this);
+}
+
+LargeImageView::~LargeImageView() {
+  delete container_;
+}
+
+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();
+
+  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 362 matching lines @@
   list_items_count_ = items.size();
 
   // Needed when CreateOrUpdateViews is called for update.
   if (!item_views_.empty())
     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) {
     DCHECK(!icon_view_ || right_content_->Contains(icon_view_));
     delete icon_view_;
     icon_view_ = nullptr;
     return;
   }
 
   if (!icon_view_) {
     icon_view_ = new ProportionalImageView(kIconViewSize);
     right_content_->AddChildView(icon_view_);
   }
 
   gfx::ImageSkia icon = notification.icon().AsImageSkia();
   icon_view_->SetImage(icon, icon.size());
 }
 
 void NotificationViewMD::CreateOrUpdateSmallIconView(
     const Notification& notification) {
   if (notification.small_image().IsEmpty())
     header_row_->ClearAppIcon();
   else
     header_row_->SetAppIcon(notification.small_image().AsImageSkia());
 }
 
 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_);
-      DCHECK(Contains(image_container_));
-      delete image_container_;
-      image_container_ = NULL;
-      image_view_ = NULL;
-    } else {
-      DCHECK(!image_view_);
+    if (image_view_) {
+      DCHECK(Contains(image_view_->container()));
+      delete image_view_;
+      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 84 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 = kMaxLinesForMessageView; i < item_views_.size(); ++i) {
     item_views_[i]->SetVisible(expanded);
   }
   if (status_view_)
     status_view_->SetVisible(expanded);
   header_row_->SetOverflowIndicator(
       list_items_count_ -
       (expanded ? item_views_.size() : kMaxLinesForMessageView));
 }
@@ skipping 10 matching lines @@
   header_row_->SetControlButtonsVisible(target_visibility);
 }
 
 NotificationControlButtonsView* NotificationViewMD::GetControlButtonsView()
     const {
   // TODO(yoshiki): have this view use NotificationControlButtonsView.
   return nullptr;
 }
 
 }  // namespace message_center