Add tinted static UI resource cache

chrome/browser/android/compositor/layer/tab_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/tab_layer.h"
 
 #include "base/i18n/rtl.h"
 #include "base/memory/ptr_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_collections.h"
@@ skipping 116 matching lines @@
                              float brightness,
                              float close_btn_width,
                              float static_to_view_blend,
                              float content_width,
                              float content_height,
                              float view_width,
                              float view_height,
                              bool show_toolbar,
                              int default_theme_color,
                              int toolbar_background_color,
+                             int default_close_button_color,
                              int close_button_color,
                              bool anonymize_toolbar,
                              int toolbar_textbox_resource_id,
                              int toolbar_textbox_background_color,
                              float toolbar_textbox_alpha,
                              float toolbar_alpha,
                              float toolbar_y_offset,
                              float side_border_scale,
                              bool attach_content,
                              bool inset_border) {
   if (alpha <= 0) {
     layer_->SetHideLayerAndSubtree(true);
     return;
   }
 
   layer_->SetHideLayerAndSubtree(false);
 
   // Grab required resources
   ui::ResourceManager::Resource* border_resource =
-      resource_manager_->GetResource(ui::ANDROID_RESOURCE_TYPE_STATIC,
-                                     border_resource_id);
+      resource_manager_->GetStaticResourceWithTint(border_resource_id,
+                                                   toolbar_background_color,
+                                                   default_theme_color);
   ui::ResourceManager::Resource* border_inner_shadow_resource =
       resource_manager_->GetResource(ui::ANDROID_RESOURCE_TYPE_STATIC,
                                      border_inner_shadow_resource_id);
   ui::ResourceManager::Resource* shadow_resource =
       resource_manager_->GetResource(ui::ANDROID_RESOURCE_TYPE_STATIC,
                                      shadow_resource_id);
   ui::ResourceManager::Resource* contour_resource =
       resource_manager_->GetResource(ui::ANDROID_RESOURCE_TYPE_STATIC,
                                      contour_resource_id);
   ui::ResourceManager::Resource* close_btn_resource =
-      resource_manager_->GetResource(ui::ANDROID_RESOURCE_TYPE_STATIC,
-                                     close_button_resource_id);
+      resource_manager_->GetStaticResourceWithTint(close_button_resource_id,
+                                                   close_button_color,
+                                                   default_close_button_color);
   ui::ResourceManager::Resource* back_logo_resource = nullptr;
 
   DecorationTitle* title_layer = nullptr;
 
   //----------------------------------------------------------------------------
   // Handle Border Scaling (Upscale/Downscale everything until final scaling)
   //----------------------------------------------------------------------------
   width /= border_scale;
   height /= border_scale;
   shadow_x /= border_scale;
@@ skipping 291 matching lines @@
     contour_shadow_->SetBounds(contour_size);
     contour_shadow_->SetOpacity(contour_alpha);
   }
 
   front_border_->SetHideLayerAndSubtree(!border_visible);
   if (border_visible) {
     front_border_->SetPosition(border_position);
     front_border_->SetBounds(border_size);
     front_border_->SetOpacity(border_alpha);
     front_border_->SetNearestNeighbor(toolbar_visible);
-
-    if (toolbar_background_color != toolbar_background_color_) {
-      toolbar_background_color_ = toolbar_background_color;
-      front_border_->SetFilters(
-          *createSolidColorFilter(toolbar_background_color).get());
-    }
   }
 
   front_border_inner_shadow_->SetHideLayerAndSubtree(
       !border_inner_shadow_visible);
   if (border_inner_shadow_visible) {
     front_border_inner_shadow_->SetPosition(border_inner_shadow_position);
     front_border_inner_shadow_->SetBounds(border_inner_shadow_size);
     front_border_inner_shadow_->SetOpacity(border_inner_shadow_alpha);
   }
 
@@ skipping 18 matching lines @@
         title_position.y() +
             (title_size.height() - title_layer->size().height()) / 2.f);
 
     title_->SetPosition(vertically_centered_position);
     title_layer->setBounds(title_size);
     title_layer->setOpacity(border_alpha);
   }
 
   close_button_->SetHideLayerAndSubtree(!close_btn_visible);
   if (close_btn_visible) {
-
-    if (close_button_color != close_button_color_) {
-      close_button_color_ = close_button_color;
-      close_button_->SetFilters(
-          *createSolidColorFilter(close_button_color).get());
-    }
-
     close_button_->SetPosition(close_button_position);
     close_button_->SetBounds(close_button_size);
     // Non-linear alpha looks better.
     close_button_->SetOpacity(close_alpha * close_alpha * border_alpha);
   }
 
   if (content_visible && attach_content) {
     {
       // content_ and back_logo_ Transforms
       gfx::Transform transform;
@@ skipping 79 matching lines @@
   // than 1.
   if (brightness != brightness_) {
     brightness_ = brightness;
     cc::FilterOperations filters;
     if (brightness_ < 1.f)
       filters.Append(cc::FilterOperation::CreateBrightnessFilter(brightness_));
     layer_->SetFilters(filters);
   }
 }
 
-std::unique_ptr<cc::FilterOperations> TabLayer::createSolidColorFilter(
-    int color) {
-  std::unique_ptr<cc::FilterOperations> filters =
-      base::WrapUnique(new cc::FilterOperations());
-  SkScalar colorMatrix[] = {
-      SkColorGetR(color) / 255.0f, 0, 0, 0, 0,
-      0, SkColorGetG(color) / 255.0f, 0, 0, 0,
-      0, 0, SkColorGetB(color) / 255.0f, 0, 0,
-      0, 0, 0, 1, 0,
-  };
-  filters->Append(cc::FilterOperation::CreateColorMatrixFilter(colorMatrix));
-  return filters;
-}
-
 scoped_refptr<cc::Layer> TabLayer::layer() {
   return layer_;
 }
 
 TabLayer::TabLayer(bool incognito,
                    ui::ResourceManager* resource_manager,
                    LayerTitleCache* layer_title_cache,
                    TabContentManager* tab_content_manager)
     : incognito_(incognito),
-      toolbar_background_color_(0),
-      close_button_color_(0),
       resource_manager_(resource_manager),
       layer_title_cache_(layer_title_cache),
       layer_(cc::Layer::Create()),
       toolbar_layer_(ToolbarLayer::Create(resource_manager)),
       title_(cc::Layer::Create()),
       content_(ContentLayer::Create(tab_content_manager)),
       side_padding_(cc::SolidColorLayer::Create()),
       bottom_padding_(cc::SolidColorLayer::Create()),
       close_button_(cc::UIResourceLayer::Create()),
       front_border_(cc::NinePatchLayer::Create()),
@@ skipping 41 matching lines @@
       title_->AddChild(layer);
     }
   }
 
   if (title)
     title->SetUIResourceIds();
 }
 
 }  //  namespace android
 }  //  namespace chrome