[Contextual Search] Add support for a static icon

chrome/browser/android/compositor/layer/contextual_search_layer.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 "chrome/browser/android/compositor/layer/contextual_search_layer.h"
 
 #include "cc/layers/layer.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/ui_resource_layer.h"
@@ skipping 25 matching lines @@
     ui::ResourceManager* resource_manager) {
   return make_scoped_refptr(new ContextualSearchLayer(resource_manager));
 }
 
 void ContextualSearchLayer::SetProperties(
     int panel_shadow_resource_id,
     int search_context_resource_id,
     int search_term_resource_id,
     int search_caption_resource_id,
     int search_bar_shadow_resource_id,
-    int panel_icon_resource_id,
+    int sprite_resource_id,
     int search_provider_icon_sprite_metadata_resource_id,
+    int static_icon_resource_id,
     int arrow_up_resource_id,
     int close_icon_resource_id,
     int progress_bar_background_resource_id,
     int progress_bar_resource_id,
     int search_promo_resource_id,
     int peek_promo_ripple_resource_id,
     int peek_promo_text_resource_id,
     float dp_to_px,
     const scoped_refptr<cc::Layer>& content_layer,
     bool search_promo_visible,
@@ skipping 16 matching lines @@
     float search_term_opacity,
     float search_term_caption_spacing,
     float search_caption_animation_percentage,
     bool search_caption_visible,
     bool search_bar_border_visible,
     float search_bar_border_height,
     bool search_bar_shadow_visible,
     float search_bar_shadow_opacity,
     bool search_provider_icon_sprite_visible,
     float search_provider_icon_sprite_completion_percentage,
+    bool static_icon_visible,
     bool thumbnail_visible,
-    float thumbnail_visibility_percentage,
-    int thumbnail_size,
+    float static_image_visibility_percentage,
+    int static_image_size,
     float arrow_icon_opacity,
     float arrow_icon_rotation,
     float close_icon_opacity,
     bool progress_bar_visible,
     float progress_bar_height,
     float progress_bar_opacity,
     int progress_bar_completion) {
 
   // Round values to avoid pixel gap between layers.
   search_bar_height = floor(search_bar_height);
 
   float search_bar_top = search_peek_promo_height;
   float search_bar_bottom = search_bar_top + search_bar_height;
   bool should_render_progress_bar =
       progress_bar_visible && progress_bar_opacity > 0.f;
 
   OverlayPanelLayer::SetResourceIds(
       search_term_resource_id,
       panel_shadow_resource_id,
       search_bar_shadow_resource_id,
-      panel_icon_resource_id,
+      sprite_resource_id,
       close_icon_resource_id);
 
   float content_view_top = search_bar_bottom + search_promo_height;
   float should_render_bar_border = search_bar_border_visible
       && !should_render_progress_bar;
 
   // -----------------------------------------------------------------
   // Overlay Panel
   // -----------------------------------------------------------------
   OverlayPanelLayer::SetProperties(
@@ skipping 253 matching lines @@
     if (progress_bar_background_.get() && progress_bar_background_->parent())
       progress_bar_background_->RemoveFromParent();
 
     if (progress_bar_.get() && progress_bar_->parent())
       progress_bar_->RemoveFromParent();
   }
 
   // ---------------------------------------------------------------------------
   // Icon Layer
   // ---------------------------------------------------------------------------
-  thumbnail_size_ = thumbnail_size;
+  static_image_size_ = static_image_size;
   SetupIconLayer(search_provider_icon_sprite_visible,
                  search_provider_icon_sprite_metadata_resource_id,
                  search_provider_icon_sprite_completion_percentage,
+                 static_icon_visible,
+                 static_icon_resource_id,
                  thumbnail_visible,
-                 thumbnail_visibility_percentage);
+                 static_image_visibility_percentage);
 }
 
 scoped_refptr<cc::Layer> ContextualSearchLayer::GetIconLayer() {
   return icon_layer_;
 }
 
 void ContextualSearchLayer::SetupIconLayer(
     bool search_provider_icon_sprite_visible,
     int search_provider_icon_sprite_metadata_resource_id,
     float search_provider_icon_sprite_completion_percentage,
+    bool static_icon_visible,
+    int static_icon_resource_id,
     bool thumbnail_visible,
-    float thumbnail_visibility_percentage) {
-  icon_layer_->SetBounds(gfx::Size(thumbnail_size_, thumbnail_size_));
+    float static_image_visibility_percentage) {
+  icon_layer_->SetBounds(gfx::Size(static_image_size_, static_image_size_));
   icon_layer_->SetMasksToBounds(true);
 
+  scoped_refptr<cc::UIResourceLayer> static_image_layer;
+
+  if (static_icon_visible) {
+    if (static_icon_layer_->parent() != icon_layer_)
+      icon_layer_->AddChild(static_icon_layer_);
+
+    ui::ResourceManager::Resource* static_icon_resource =
+        resource_manager_->GetResource(ui::ANDROID_RESOURCE_TYPE_STATIC,
+                                       static_icon_resource_id);
+    static_icon_layer_->SetUIResourceId(
+        static_icon_resource->ui_resource->id());
+    static_icon_layer_->SetBounds(gfx::Size(static_image_size_,
+                                            static_image_size_));
+
+    SetStaticImageProperties(static_icon_layer_, 0, 0,
+                             static_image_visibility_percentage);
+  } else if (static_icon_layer_->parent()) {
+    static_icon_layer_->RemoveFromParent();
+  }
+
   // Thumbnail
-  if (thumbnail_visible) {
+  if (!static_icon_visible && thumbnail_visible) {
     if (thumbnail_layer_->parent() != icon_layer_)
           icon_layer_->AddChild(thumbnail_layer_);
 
-    thumbnail_layer_->SetOpacity(thumbnail_visibility_percentage);
-
-    // When animating, the thumbnail and icon sprite slide through
-    // |icon_layer_|. This effect is achieved by changing the y-offset
-    // for each child layer.
-    // If the thumbnail has a height less than |thumbnail_size_|, it will have
-    // a top margin that needs to be accounted for while running the
-    // animation. The final |thumbnail_y_offset| should be equal to
-    // |thumbnail_top_margin_|.
-    float thumbnail_y_offset =
-        (thumbnail_size_ * (1.f - thumbnail_visibility_percentage))
-        + thumbnail_top_margin_;
-    thumbnail_layer_->SetPosition(
-        gfx::PointF(thumbnail_side_margin_, thumbnail_y_offset));
+    SetStaticImageProperties(thumbnail_layer_,
+                             thumbnail_top_margin_,
+                             thumbnail_side_margin_,
+                             static_image_visibility_percentage);
   } else if (thumbnail_layer_->parent()) {
     thumbnail_layer_->RemoveFromParent();
   }
 
   // Search Provider Icon Sprite
   if (search_provider_icon_sprite_visible) {
     if (search_provider_icon_sprite_->layer()->parent() != icon_layer_)
       icon_layer_->AddChild(search_provider_icon_sprite_->layer().get());
 
     search_provider_icon_sprite_->DrawSpriteFrame(
         resource_manager_,
         panel_icon_resource_id_,
         search_provider_icon_sprite_metadata_resource_id,
         search_provider_icon_sprite_completion_percentage);
 
     search_provider_icon_sprite_->layer()->SetOpacity(
-        1.f - thumbnail_visibility_percentage);
+        1.f - static_image_visibility_percentage);
 
     float icon_y_offset =
-        -(thumbnail_size_ * thumbnail_visibility_percentage);
+        -(static_image_size_ * static_image_visibility_percentage);
     search_provider_icon_sprite_->layer()->SetPosition(
         gfx::PointF(0.f, icon_y_offset));
 
   } else if (search_provider_icon_sprite_->layer().get() &&
       search_provider_icon_sprite_->layer()->parent()) {
     search_provider_icon_sprite_->layer()->RemoveFromParent();
   }
 }
 
+void ContextualSearchLayer::SetStaticImageProperties(
+    scoped_refptr<cc::UIResourceLayer> static_image_layer,
+    float top_margin,
+    float side_margin,
+    float visibility_percentage) {
+  static_image_layer->SetOpacity(visibility_percentage);
+
+  // When animating, the static image and icon sprite slide through
+  // |icon_layer_|. This effect is achieved by changing the y-offset
+  // for each child layer.
+  // If the static image has a height less than |static_image_size_|, it will
+  // have a top margin that needs to be accounted for while running the
+  // animation. The final |static_image_y_offset| should be equal to
+  // |tpp_margin|.
+  float thumbnail_y_offset =

[Donn Denman, 2016/10/24 23:56:20]

Nit: change to static_image_y_offset.

[Theresa, 2016/10/25 00:32:48]

Done.

+      (static_image_size_ * (1.f - visibility_percentage))
+      + top_margin;
+  static_image_layer->SetPosition(
+      gfx::PointF(side_margin, thumbnail_y_offset));
+}
+
 void ContextualSearchLayer::SetupTextLayer(
     float bar_top,
     float bar_height,
     float search_text_layer_min_height,
     int caption_resource_id,
     bool caption_visible,
     float animation_percentage,
     int context_resource_id,
     float context_opacity,
     float term_caption_spacing) {
@@ skipping 109 matching lines @@
   float caption_top = layer_height * (1.f - animation_percentage)
                     + caption_top_end * animation_percentage;
 
   bar_text_->SetPosition(gfx::PointF(0.f, term_top));
   search_context_->SetPosition(gfx::PointF(0.f, term_top));
   search_caption_->SetPosition(gfx::PointF(0.f, caption_top));
 }
 
 void ContextualSearchLayer::SetThumbnail(const SkBitmap* thumbnail) {
   // Determine the scaled thumbnail width and height. If both the height and
-  // width of |thumbnail| are larger than |thumbnail_size_|, the thumbnail will
-  // be scaled down by a call to Layer::SetBounds() below.
+  // width of |thumbnail| are larger than |static_image_size_|, the thumbnail
+  // will be scaled down by a call to Layer::SetBounds() below.
   int min_dimension = std::min(thumbnail->width(), thumbnail->height());
   int scaled_thumbnail_width = thumbnail->width();
   int scaled_thumbnail_height = thumbnail->height();
-  if (min_dimension > thumbnail_size_) {
+  if (min_dimension > static_image_size_) {
     scaled_thumbnail_width =
-        scaled_thumbnail_width * thumbnail_size_ / min_dimension;
+        scaled_thumbnail_width * static_image_size_ / min_dimension;
     scaled_thumbnail_height =
-        scaled_thumbnail_height * thumbnail_size_ / min_dimension;
+        scaled_thumbnail_height * static_image_size_ / min_dimension;
   }
 
   // Determine the UV transform coordinates. This will crop the thumbnail.
   // (0, 0) is the default top left corner. (1, 1) is the default bottom
   // right corner.
   float top_left_x = 0;
   float top_left_y = 0;
   float bottom_right_x = 1;
   float bottom_right_y = 1;
 
-  if (scaled_thumbnail_width > thumbnail_size_) {
+  if (scaled_thumbnail_width > static_image_size_) {
     // Crop an even amount on the left and right sides of the thumbnail.
-    float top_left_x_px = (scaled_thumbnail_width - thumbnail_size_) / 2.f;
-    float bottom_right_x_px = top_left_x_px + thumbnail_size_;
+    float top_left_x_px = (scaled_thumbnail_width - static_image_size_) / 2.f;
+    float bottom_right_x_px = top_left_x_px + static_image_size_;
 
     top_left_x = top_left_x_px / scaled_thumbnail_width;
     bottom_right_x = bottom_right_x_px / scaled_thumbnail_width;
-  } else if (scaled_thumbnail_height > thumbnail_size_) {
+  } else if (scaled_thumbnail_height > static_image_size_) {
     // Crop an even amount on the top and bottom of the thumbnail.
-    float top_left_y_px = (scaled_thumbnail_height - thumbnail_size_) / 2.f;
-    float bottom_right_y_px = top_left_y_px + thumbnail_size_;
+    float top_left_y_px = (scaled_thumbnail_height - static_image_size_) / 2.f;
+    float bottom_right_y_px = top_left_y_px + static_image_size_;
 
     top_left_y = top_left_y_px / scaled_thumbnail_height;
     bottom_right_y = bottom_right_y_px / scaled_thumbnail_height;
   }
 
   // If the original |thumbnail| height or width is smaller than
-  // |thumbnail_size_| determine the side and top margins needed to center
+  // |static_image_size_| determine the side and top margins needed to center
   // the thumbnail.
   thumbnail_side_margin_ = 0;
   thumbnail_top_margin_ = 0;
 
-  if (scaled_thumbnail_width < thumbnail_size_) {
-    thumbnail_side_margin_ = (thumbnail_size_ - scaled_thumbnail_width) / 2.f;
+  if (scaled_thumbnail_width < static_image_size_) {
+    thumbnail_side_margin_ =
+        (static_image_size_ - scaled_thumbnail_width) / 2.f;
   }
 
-  if (scaled_thumbnail_height < thumbnail_size_) {
-    thumbnail_top_margin_ = (thumbnail_size_ - scaled_thumbnail_height) / 2.f;
+  if (scaled_thumbnail_height < static_image_size_) {
+    thumbnail_top_margin_ =
+        (static_image_size_ - scaled_thumbnail_height) / 2.f;
   }
 
   // Determine the layer bounds. This will down scale the thumbnail if
-  // necessary and ensure it is displayed at |thumbnail_size_|. If
+  // necessary and ensure it is displayed at |static_image_size_|. If
   // either the original |thumbnail| height or width is smaller than
-  // |thumbnail_size_|, the thumbnail will not be scaled.
-  int layer_width = std::min(thumbnail_size_, scaled_thumbnail_width);
-  int layer_height = std::min(thumbnail_size_, scaled_thumbnail_height);
+  // |static_image_size_|, the thumbnail will not be scaled.
+  int layer_width = std::min(static_image_size_, scaled_thumbnail_width);
+  int layer_height = std::min(static_image_size_, scaled_thumbnail_height);
 
   // UIResourceLayer requires an immutable copy of the input |thumbnail|.
   SkBitmap thumbnail_copy;
   if (thumbnail->isImmutable()) {
     thumbnail_copy = *thumbnail;
   } else {
     thumbnail->copyTo(&thumbnail_copy);
     thumbnail_copy.setImmutable();
   }
 
   thumbnail_layer_->SetBitmap(thumbnail_copy);
   thumbnail_layer_->SetBounds(gfx::Size(layer_width, layer_height));
   thumbnail_layer_->SetPosition(
       gfx::PointF(thumbnail_side_margin_, thumbnail_top_margin_));
   thumbnail_layer_->SetUV(gfx::PointF(top_left_x, top_left_y),
                           gfx::PointF(bottom_right_x, bottom_right_y));
 }
 
 ContextualSearchLayer::ContextualSearchLayer(
     ui::ResourceManager* resource_manager)
     : OverlayPanelLayer(resource_manager),
       search_context_(cc::UIResourceLayer::Create()),
       icon_layer_(cc::Layer::Create()),
       search_provider_icon_sprite_(CrushedSpriteLayer::Create()),
       thumbnail_layer_(cc::UIResourceLayer::Create()),
+      static_icon_layer_(cc::UIResourceLayer::Create()),
       arrow_icon_(cc::UIResourceLayer::Create()),
       search_promo_(cc::UIResourceLayer::Create()),
       search_promo_container_(cc::SolidColorLayer::Create()),
       peek_promo_container_(cc::SolidColorLayer::Create()),
       peek_promo_ripple_(cc::NinePatchLayer::Create()),
       peek_promo_text_(cc::UIResourceLayer::Create()),
       progress_bar_(cc::NinePatchLayer::Create()),
       progress_bar_background_(cc::NinePatchLayer::Create()),
       search_caption_(cc::UIResourceLayer::Create()),
       text_layer_(cc::UIResourceLayer::Create()) {
@@ skipping 22 matching lines @@
   search_promo_->SetIsDrawable(true);
 
   // Progress Bar Background
   progress_bar_background_->SetIsDrawable(true);
   progress_bar_background_->SetFillCenter(true);
 
   // Progress Bar
   progress_bar_->SetIsDrawable(true);
   progress_bar_->SetFillCenter(true);
 
-  // Icon
+  // Icon - holds thumbnail, search provider sprite and/or static icon
   icon_layer_->SetIsDrawable(true);
   layer_->AddChild(icon_layer_);
 
   // Thumbnail
   thumbnail_layer_->SetIsDrawable(true);
 
+  // Static icon
+  static_icon_layer_->SetIsDrawable(true);
+
   // Content layer
   text_layer_->SetIsDrawable(true);
   // NOTE(mdjones): This can be called multiple times to add other text layers.
   AddBarTextLayer(text_layer_);
   text_layer_->AddChild(search_context_);
 }
 
 ContextualSearchLayer::~ContextualSearchLayer() {
 }
 
 }  //  namespace android