Show Play Store rating and price in app list

ui/app_list/views/tile_item_view.cc

 // Copyright 2014 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/app_list/views/tile_item_view.h"
 
 #include "ui/app_list/app_list_constants.h"
 #include "ui/app_list/app_list_features.h"
 #include "ui/app_list/views/app_list_main_view.h"
 #include "ui/gfx/canvas.h"
+#include "ui/gfx/font_list.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/views/background.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 
 namespace {
 
 constexpr int kTopPadding = 5;
 constexpr int kTileSize = 90;
 constexpr int kIconTitleSpacing = 6;
 
 constexpr int kBadgeBackgroundRadius = 10;
 
+// Layout constants used when fullscreen app list feature is enabled.
+constexpr int kItemTopPadding = 4;
+constexpr int kItemWidth = 80;
+constexpr int kItemHeight = 90;
+
 // The background image source for badge.
 class BadgeBackgroundImageSource : public gfx::CanvasImageSource {
  public:
   explicit BadgeBackgroundImageSource(int size)
       : CanvasImageSource(gfx::Size(size, size), false),
         radius_(static_cast<float>(size / 2)) {}
   ~BadgeBackgroundImageSource() override = default;
 
  private:
   // gfx::CanvasImageSource overrides:
@@ skipping 12 matching lines @@
 
 }  // namespace
 
 namespace app_list {
 
 TileItemView::TileItemView()
     : views::CustomButton(this),
       parent_background_color_(SK_ColorTRANSPARENT),
       icon_(new views::ImageView),
       badge_(nullptr),
-      title_(new views::Label) {
+      title_(new views::Label),
+      price_(nullptr),
+      rating_(nullptr),
+      is_fullscreen_app_list_enabled_(features::IsFullscreenAppListEnabled()) {
   // Prevent the icon view from interfering with our mouse events.
   icon_->set_can_process_events_within_subtree(false);
   icon_->SetVerticalAlignment(views::ImageView::LEADING);
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   title_->SetAutoColorReadabilityEnabled(false);
   title_->SetEnabledColor(kGridTitleColor);
   title_->SetFontList(rb.GetFontList(kItemTextFontStyle));
   title_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
   title_->SetHandlesTooltips(false);
 
   AddChildView(icon_);
-  if (features::IsFullscreenAppListEnabled()) {
+  AddChildView(title_);
+
+  if (is_fullscreen_app_list_enabled_) {
     badge_ = new views::ImageView();
     badge_->set_can_process_events_within_subtree(false);
     badge_->SetVerticalAlignment(views::ImageView::LEADING);
     AddChildView(badge_);
+
+    price_ = new views::Label;
+    price_->SetEnabledColor(kAppPriceColor);
+    price_->SetFontList(gfx::FontList(kAppPriceFontList));

[xiyuan, 2017/06/20 22:19:23]

Roboto is the current default UI font. Let's try not create UI font like this.
Otherwise, when UI spec changes (which happened in the past), we would have to
revisit and change the font family.

Instead, create FontList like this:
 
ui::ResourceBundle::GetSharedInstance().GetFontList(ui::ResourceBundle::BaseFont)

and do DeriveWithSizeDelta(delta) if the font size does not match spec.

[weidongg, 2017/06/22 00:59:16]

Good to know, thanks. Done.

+    price_->SetHorizontalAlignment(gfx::ALIGN_RIGHT);
+    AddChildView(price_);
+
+    rating_ = new views::Label;
+    rating_->SetEnabledColor(kAppRatingColor);
+    rating_->SetFontList(gfx::FontList(kAppRatingFontList));
+    rating_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+    AddChildView(rating_);
   }
-  AddChildView(title_);
 }
 
 TileItemView::~TileItemView() = default;
 
 void TileItemView::SetSelected(bool selected) {
   if (selected == selected_)
     return;
 
   selected_ = selected;
   UpdateBackgroundColor();
@@ skipping 53 matching lines @@
   badge_->SetImage(gfx::ImageSkiaOperations::CreateImageWithDropShadow(
       icon_with_background, shadow_values));
   badge_->SetVisible(true);
 }
 
 void TileItemView::SetTitle(const base::string16& title) {
   title_->SetText(title);
   SetAccessibleName(title);
 }
 
+void TileItemView::SetPrice(const base::string16& price) {
+  if (!price_)
+    return;
+  price_->SetText(price);
+}
+
+void TileItemView::SetRating(const base::string16& rating) {
+  if (!rating_)
+    return;
+  rating_->SetText(rating);
+}
+
 void TileItemView::StateChanged(ButtonState old_state) {
   UpdateBackgroundColor();
 }
 
 void TileItemView::Layout() {

[Qiang(Joe) Xu, 2017/06/21 17:43:12]

I think we would better not do Layout here. TileItemView is no longer a common
Layout() method for both start page and search box searched results.

My idea is to leave the Layout() not changed for TileItemView for old behavior.
Instead, we implement it in SearchResultTileItemView based on the display_type,
whether it is SearchResult::DISPLAY_RECOMMENDATION or DISPLAY_TITLE (in your
case).

I have a CL about this prototype. Let us see how it works.

[weidongg, 2017/06/22 00:59:16]

Yes, agree. Rebased to your change.

   gfx::Rect rect(GetContentsBounds());
   if (rect.IsEmpty())
     return;
 
-  rect.Inset(0, kTopPadding, 0, 0);
+  rect.Inset(0, is_fullscreen_app_list_enabled_ ? kItemTopPadding : kTopPadding,
+             0, 0);
   icon_->SetBoundsRect(rect);
 
   if (badge_) {
     gfx::Rect badge_rect(rect);
     gfx::Size icon_size = icon_->GetImage().size();
     badge_rect.Offset(
         (icon_size.width() - kAppBadgeIconSize) / 2,
         icon_size.height() - kBadgeBackgroundRadius - kAppBadgeIconSize / 2);
     badge_->SetBoundsRect(badge_rect);
   }
 
   rect.Inset(0, kGridIconDimension + kIconTitleSpacing, 0, 0);
   rect.set_height(title_->GetPreferredSize().height());
   title_->SetBoundsRect(rect);
+
+  if (price_) {
+    gfx::Rect price_rect(rect);
+    price_rect.Inset(0, title_->GetPreferredSize().height(), 0, 0);
+    price_rect.set_height(price_->GetPreferredSize().height());
+    price_->SetBoundsRect(price_rect);
+  }
+
+  if (rating_) {
+    gfx::Rect rating_rect(rect);
+    rating_rect.Inset(0, title_->GetPreferredSize().height(), 0, 0);
+    rating_rect.set_height(rating_->GetPreferredSize().height());
+    rating_->SetBoundsRect(rating_rect);
+  }
 }
 
 const char* TileItemView::GetClassName() const {
   return "TileItemView";
 }
 
 void TileItemView::ImageShadowAnimationProgressed(
     ImageShadowAnimator* animator) {
   icon_->SetImage(animator->shadow_image());
 }
@@ skipping 18 matching lines @@
   // Tell the label what color it will be drawn onto. It will use whether the
   // background color is opaque or transparent to decide whether to use subpixel
   // rendering. Does not actually set the label's background color.
   title_->SetBackgroundColor(background_color);
 
   SetBackground(std::move(background));
   SchedulePaint();
 }
 
 gfx::Size TileItemView::CalculatePreferredSize() const {
-  return gfx::Size(kTileSize, kTileSize);
+  if (is_fullscreen_app_list_enabled_)
+    return gfx::Size(kItemWidth, kItemHeight);
+  else

[xiyuan, 2017/06/20 22:19:23]

Don't use else after return.

See
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...

[weidongg, 2017/06/22 00:59:16]

Done.

+    return gfx::Size(kTileSize, kTileSize);
 }
 
 bool TileItemView::GetTooltipText(const gfx::Point& p,
                                   base::string16* tooltip) const {
   // Use the label to generate a tooltip, so that it will consider its text
   // truncation in making the tooltip. We do not want the label itself to have a
   // tooltip, so we only temporarily enable it to get the tooltip text from the
   // label, then disable it again.
   title_->SetHandlesTooltips(true);
   bool handled = title_->GetTooltipText(p, tooltip);
   title_->SetHandlesTooltips(false);
   return handled;
 }
 
 }  // namespace app_list