Desaturate the favicon shown in the tab when a network error is encountered

chrome/browser/ui/views/tabs/tab.cc

 // Copyright (c) 2012 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/ui/views/tabs/tab.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 98 matching lines @@
 
 // The minimum opacity (out of 1) when a tab (either active or inactive) is
 // throbbing in the immersive mode light strip.
 const double kImmersiveTabMinThrobOpacity = 0.66;
 
 // Number of steps in the immersive mode loading animation.
 const int kImmersiveLoadingStepCount = 32;
 
 const char kTabCloseButtonName[] = "TabCloseButton";
 
+// Desaturate favicon HSL shift values.
+const double kDesaturateHue = -1.0;
+const double kDesaturateSaturation = 0.0;
+const double kDesaturateLightness = 0.6;
+
 // Parameters for PaintTabBackgroundUsingParams().
 struct PaintBackgroundParams {
   PaintBackgroundParams(bool is_active,
                         gfx::ImageSkia* fill_image_ptr,
                         bool has_custom_image,
                         gfx::Rect rect,
                         SkColor stroke_color,
                         SkColor toolbar_color,
                         SkColor background_tab_color)
       : is_active(is_active),
@@ skipping 442 matching lines @@
     canvas->DrawImageInt(*stroke_images->image_l, 0, 0);
     canvas->TileImageInt(
         *stroke_images->image_c, stroke_images->l_width, 0,
         rect.width() - stroke_images->l_width - stroke_images->r_width,
         rect.height());
     canvas->DrawImageInt(*stroke_images->image_r,
                          rect.width() - stroke_images->r_width, 0);
   }
 }
 
+// Desaturates the favicon. Should only be used for when a tab encounters a
+// network error state.
+void PaintDesaturatedFavIcon(gfx::Canvas* canvas,
+                             gfx::ImageSkia& favicon,
+                             const gfx::Rect& bounds) {
+  color_utils::HSL shift = {kDesaturateHue,
+                            kDesaturateSaturation,
+                            kDesaturateLightness};
+  gfx::ImageSkia desaturated_favicon =
+      gfx::ImageSkiaOperations::CreateHSLShiftedImage(favicon, shift);
+  if (!bounds.IsEmpty()) {
+    canvas->DrawImageInt(desaturated_favicon, 0, 0,
+                         bounds.width(), bounds.height(),
+                         bounds.x(), bounds.y(), bounds.width(),
+                         bounds.height(), false);
+  } else {
+    canvas->DrawImageInt(desaturated_favicon, 0, 0);
+  }
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FaviconCrashAnimation
 //
 //  A custom animation subclass to manage the favicon crash animation.
 class Tab::FaviconCrashAnimation : public gfx::LinearAnimation,
                                    public gfx::AnimationDelegate {
  public:
   explicit FaviconCrashAnimation(Tab* target)
@@ skipping 161 matching lines @@
   loading_start_time_ = base::TimeTicks();
   waiting_state_ = gfx::ThrobberWaitingState();
 }
 
 bool Tab::ThrobberView::CanProcessEventsWithinSubtree() const {
   return false;
 }
 
 void Tab::ThrobberView::OnPaint(gfx::Canvas* canvas) {
   const TabRendererData::NetworkState state = owner_->data().network_state;
-  if (state == TabRendererData::NETWORK_STATE_NONE)
+  if (state == TabRendererData::NETWORK_STATE_NONE ||
+      state == TabRendererData::NETWORK_STATE_ERROR)
     return;
 
   const ui::ThemeProvider* tp = GetThemeProvider();
   const gfx::Rect bounds = GetLocalBounds();
   if (state == TabRendererData::NETWORK_STATE_WAITING) {
     if (waiting_start_time_ == base::TimeTicks())
       waiting_start_time_ = base::TimeTicks::Now();
 
     waiting_state_.elapsed_time = base::TimeTicks::Now() - waiting_start_time_;
     gfx::PaintThrobberWaiting(
@@ skipping 117 matching lines @@
 void Tab::AlertStateChanged() {
   Layout();
 }
 
 bool Tab::IsSelected() const {
   return controller_->IsTabSelected(this);
 }
 
 void Tab::SetData(const TabRendererData& data) {
   DCHECK(GetWidget());
-
   if (data_.Equals(data))
     return;
 
   TabRendererData old(data_);
   UpdateLoadingAnimation(data.network_state);
   data_ = data;
 
   base::string16 title = data_.title;
   if (title.empty()) {
     title = data_.loading ?
@@ skipping 21 matching lines @@
     showing_pinned_tab_title_changed_indicator_ = false;
 
   DataChanged(old);
 
   Layout();
   SchedulePaint();
 }
 
 void Tab::UpdateLoadingAnimation(TabRendererData::NetworkState state) {
   if (state == data_.network_state &&
-      state == TabRendererData::NETWORK_STATE_NONE) {
-    // If the network state is none and hasn't changed, do nothing. Otherwise we
-    // need to advance the animation frame.
+      (state == TabRendererData::NETWORK_STATE_NONE ||
+       state == TabRendererData::NETWORK_STATE_ERROR)) {
+    // If the network state is none or is an network error and hasn't changed,
+    // do nothing. Otherwise we need to advance the animation frame.
     return;
   }
 
   data_.network_state = state;
   AdvanceLoadingAnimation();
 }
 
 void Tab::StartPulse() {
   pulse_animation_->StartThrobbing(std::numeric_limits<int>::max());
 }
@@ skipping 632 matching lines @@
     const gfx::Rect& favicon_draw_bounds) {
   // The pinned tab title changed indicator consists of two parts:
   // . a clear (totally transparent) part over the bottom right (or left in rtl)
   //   of the favicon. This is done by drawing the favicon to a canvas, then
   //   drawing the clear part on top of the favicon.
   // . a circle in the bottom right (or left in rtl) of the favicon.
   if (!favicon_.isNull()) {
     const float kIndicatorCropRadius = 4.5;
     gfx::Canvas icon_canvas(gfx::Size(gfx::kFaviconSize, gfx::kFaviconSize),
                             canvas->image_scale(), false);
-    icon_canvas.DrawImageInt(favicon_, 0, 0);
+
+    if (data().network_state == TabRendererData::NETWORK_STATE_ERROR)
+      PaintDesaturatedFavIcon(&icon_canvas, favicon_, gfx::Rect());
+    else
+      icon_canvas.DrawImageInt(favicon_, 0, 0);
+
     SkPaint clear_paint;
     clear_paint.setAntiAlias(true);
     clear_paint.setXfermodeMode(SkXfermode::kClear_Mode);
     const int circle_x = base::i18n::IsRTL() ? 0 : gfx::kFaviconSize;
     icon_canvas.DrawCircle(gfx::PointF(circle_x, gfx::kFaviconSize),
                            kIndicatorCropRadius, clear_paint);
     canvas->DrawImageInt(gfx::ImageSkia(icon_canvas.ExtractImageRep()), 0, 0,
                          favicon_draw_bounds.width(),
                          favicon_draw_bounds.height(), favicon_draw_bounds.x(),
                          favicon_draw_bounds.y(), favicon_draw_bounds.width(),
@@ skipping 16 matching lines @@
 
 void Tab::PaintIcon(gfx::Canvas* canvas) {
   gfx::Rect bounds = favicon_bounds_;
   bounds.set_x(GetMirroredXForRect(bounds));
   bounds.Offset(0, favicon_hiding_offset_);
   bounds.Intersect(GetContentsBounds());
   if (bounds.IsEmpty())
     return;
 
   // Throbber will do its own painting.
-  if (data().network_state != TabRendererData::NETWORK_STATE_NONE)
+  if (data().network_state != TabRendererData::NETWORK_STATE_NONE &&
+      data().network_state != TabRendererData::NETWORK_STATE_ERROR)
     return;
 
   // Ensure that |favicon_| is created.
   if (favicon_.isNull()) {
     ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
     favicon_ = should_display_crashed_favicon_
                    ? *rb->GetImageSkiaNamed(IDR_CRASH_SAD_FAVICON)
                    : data().favicon;
     // Themify the icon if it's a chrome:// page or if it's the sadtab favicon.
     // This ensures chrome:// pages are visible over the tab background. This is
     // similar to code in the bookmarks bar.
     if (!favicon_.isNull() &&
         (should_display_crashed_favicon_ ||
          favicon_.BackedBySameObjectAs(
              *rb->GetImageSkiaNamed(IDR_DEFAULT_FAVICON)) ||
          ShouldThemifyFaviconForUrl(data().url))) {
       favicon_ = gfx::ImageSkiaOperations::CreateHSLShiftedImage(
           favicon_, GetThemeProvider()->GetTint(ThemeProperties::TINT_BUTTONS));
     }
   }
 
   if (showing_pinned_tab_title_changed_indicator_ &&
       !should_display_crashed_favicon_) {
     PaintPinnedTabTitleChangedIndicatorAndIcon(canvas, bounds);
   } else if (!favicon_.isNull()) {
-    canvas->DrawImageInt(favicon_, 0, 0, bounds.width(), bounds.height(),
-                         bounds.x(), bounds.y(), bounds.width(),
-                         bounds.height(), false);
+    // Desaturate favicons of tabs with network errors.
+    if (data().network_state == TabRendererData::NETWORK_STATE_ERROR) {
+      PaintDesaturatedFavIcon(canvas, favicon_, bounds);
+    } else {
+      canvas->DrawImageInt(favicon_, 0, 0, bounds.width(), bounds.height(),
+                           bounds.x(), bounds.y(), bounds.width(),
+                           bounds.height(), false);
+    }
   }
 }
 
 void Tab::AdvanceLoadingAnimation() {
   const TabRendererData::NetworkState state = data().network_state;
   if (controller_->IsImmersiveStyle()) {
     throbber_->SetVisible(false);
     if (state == TabRendererData::NETWORK_STATE_WAITING) {
       // Waiting steps backwards.
       immersive_loading_step_ =
           (immersive_loading_step_ - 1 + kImmersiveLoadingStepCount) %
           kImmersiveLoadingStepCount;
     } else if (state == TabRendererData::NETWORK_STATE_LOADING) {
       immersive_loading_step_ =
           (immersive_loading_step_ + 1) % kImmersiveLoadingStepCount;
     } else {
       immersive_loading_step_ = 0;
     }
 
     SchedulePaintInRect(GetImmersiveBarRect());
     return;
   }
 
-  if (state == TabRendererData::NETWORK_STATE_NONE) {
+  if (state == TabRendererData::NETWORK_STATE_NONE ||
+      state == TabRendererData::NETWORK_STATE_ERROR) {
     throbber_->ResetStartTimes();
     throbber_->SetVisible(false);
     ScheduleIconPaint();
     return;
   }
 
   // Since the throbber can animate for a long time, paint to a separate layer
   // when possible to reduce repaint overhead.
   const bool paint_to_layer = controller_->CanPaintThrobberToLayer();
   if (paint_to_layer != !!throbber_->layer()) {
@@ skipping 124 matching lines @@
 gfx::Rect Tab::GetImmersiveBarRect() const {
   // The main bar is as wide as the normal tab's horizontal top line.
   // This top line of the tab extends a few pixels left and right of the
   // center image due to pixels in the rounded corner images.
   const int kBarPadding = 1;
   int main_bar_left = g_active_images.l_width - kBarPadding;
   int main_bar_right = width() - g_active_images.r_width + kBarPadding;
   return gfx::Rect(
       main_bar_left, 0, main_bar_right - main_bar_left, kImmersiveBarHeight);
 }