[Merge To M58]Fix Default icon issue when cached icon file is corrupted.

chrome/browser/ui/app_list/arc/arc_app_list_prefs.cc

 // Copyright 2015 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/app_list/arc/arc_app_list_prefs.h"
 
 #include <stddef.h>
 
 #include <string>
 
@@ skipping 286 matching lines @@
 
   return ToIconPath(default_app->app_path, scale_factor);
 }
 
 base::FilePath ArcAppListPrefs::GetIconPath(
     const std::string& app_id,
     ui::ScaleFactor scale_factor) const {
   return ToIconPath(GetAppPath(app_id), scale_factor);
 }
 
+bool ArcAppListPrefs::IsIconRequestRecorded(
+    const std::string& app_id,
+    ui::ScaleFactor scale_factor) const {
+  const auto iter = request_icon_recorded_.find(app_id);
+  if (iter == request_icon_recorded_.end())
+    return false;
+  return iter->second & (1 << scale_factor);
+}
+
+void ArcAppListPrefs::MaybeRemoveIconRequestRecord(const std::string& app_id) {
+  request_icon_recorded_.erase(app_id);
+}
+
+void ArcAppListPrefs::ClearIconRequestRecord() {
+  request_icon_recorded_.clear();
+}
+
 void ArcAppListPrefs::RequestIcon(const std::string& app_id,
                                   ui::ScaleFactor scale_factor) {
   if (!IsRegistered(app_id)) {
     VLOG(2) << "Request to load icon for non-registered app: " << app_id << ".";
     return;
   }
 
-  // In case app is not ready, defer this request.
-  if (!ready_apps_.count(app_id)) {
-    request_icon_deferred_[app_id] =
-        request_icon_deferred_[app_id] | 1 << scale_factor;
+  // In case app is not ready, recorded request will be send to ARC when app
+  // becomes ready.
+  // This record will prevent ArcAppIcon from resending request to ARC for app
+  // icon when icon file decode failure is suffered in case app sends bad icon.
+  request_icon_recorded_[app_id] |= (1 << scale_factor);
+
+  if (!ready_apps_.count(app_id))
     return;
-  }
 
   if (!app_instance_holder_->has_instance()) {
     // AppInstance should be ready since we have app_id in ready_apps_. This
     // can happen in browser_tests.
     return;
   }
 
   std::unique_ptr<AppInfo> app_info = GetApp(app_id);
   if (!app_info) {
     VLOG(2) << "Failed to get app info: " << app_id << ".";
@@ skipping 15 matching lines @@
     if (!app_instance)
       return;  // The instance version on ARC side was too old.
     app_instance->RequestIcon(
         app_info->icon_resource_id,
         static_cast<arc::mojom::ScaleFactor>(scale_factor),
         base::Bind(&ArcAppListPrefs::OnIcon, base::Unretained(this), app_id,
                    static_cast<arc::mojom::ScaleFactor>(scale_factor)));
   }
 }
 
+void ArcAppListPrefs::MaybeRequestIcon(const std::string& app_id,
+                                       ui::ScaleFactor scale_factor) {
+  if (!IsIconRequestRecorded(app_id, scale_factor))
+    RequestIcon(app_id, scale_factor);
+}
+
 void ArcAppListPrefs::SetNotificationsEnabled(const std::string& app_id,
                                               bool enabled) {
   if (!IsRegistered(app_id)) {
     VLOG(2) << "Request to set notifications enabled flag for non-registered "
             << "app:" << app_id << ".";
     return;
   }
 
   std::unique_ptr<AppInfo> app_info = GetApp(app_id);
   if (!app_info) {
@@ skipping 332 matching lines @@
   app_instance->Init(binding_.CreateInterfacePtrAndBind());
   app_instance->RefreshAppList();
 }
 
 void ArcAppListPrefs::OnInstanceClosed() {
   DisableAllApps();
   installing_packages_count_ = 0;
   default_apps_installations_.clear();
   detect_default_app_availability_timeout_.Stop();
   binding_.Close();
+  ClearIconRequestRecord();
 
   if (sync_service_) {
     sync_service_->StopSyncing(syncer::ARC_PACKAGE);
     sync_service_ = nullptr;
   }
 
   is_initialized_ = false;
   package_list_initial_refreshed_ = false;
 }
 
@@ skipping 78 matching lines @@
                      icon_resource_id, base::Time(), GetInstallTime(app_id),
                      sticky, notifications_enabled, true,
                      launchable && arc::ShouldShowInLauncher(app_id), shortcut,
                      launchable, orientation_lock);
     for (auto& observer : observer_list_)
       observer.OnAppRegistered(app_id, app_info);
     tracked_apps_.insert(app_id);
   }
 
   if (app_ready) {
-    auto deferred_icons = request_icon_deferred_.find(app_id);
-    if (deferred_icons != request_icon_deferred_.end()) {
+    auto pending_icons = request_icon_recorded_.find(app_id);
+    if (pending_icons != request_icon_recorded_.end()) {
       for (uint32_t i = ui::SCALE_FACTOR_100P; i < ui::NUM_SCALE_FACTORS; ++i) {
-        if (deferred_icons->second & (1 << i)) {
+        if (pending_icons->second & (1 << i)) {
           RequestIcon(app_id, static_cast<ui::ScaleFactor>(i));
         }
       }
-      request_icon_deferred_.erase(deferred_icons);
     }
 
     bool deferred_notifications_enabled;
     if (SetNotificationsEnabledDeferred(prefs_).Get(
             app_id, &deferred_notifications_enabled)) {
       SetNotificationsEnabled(app_id, deferred_notifications_enabled);
     }
   }
 }
 
 void ArcAppListPrefs::RemoveApp(const std::string& app_id) {
   // Delete cached icon if there is any.
   std::unique_ptr<ArcAppListPrefs::AppInfo> app_info = GetApp(app_id);
   if (app_info && !app_info->icon_resource_id.empty()) {
     arc::RemoveCachedIcon(app_info->icon_resource_id);
   }
 
+  MaybeRemoveIconRequestRecord(app_id);
+
   // From now, app is not available.
   ready_apps_.erase(app_id);
 
   // app_id may be released by observers, get the path first. It should be done
   // before removing prefs entry in order not to mix with pre-build default apps
   // files.
   const base::FilePath app_path = GetAppPath(app_id);
 
   // Remove from prefs.
   DictionaryPrefUpdate update(prefs_, prefs::kArcApps);
@@ skipping 532 matching lines @@
                                           int64_t last_backup_android_id,
                                           int64_t last_backup_time,
                                           bool should_sync,
                                           bool system)
     : package_name(package_name),
       package_version(package_version),
       last_backup_android_id(last_backup_android_id),
       last_backup_time(last_backup_time),
       should_sync(should_sync),
       system(system) {}