[Merge-M54] arc: Make Play Store item persistent in app list.

chrome/browser/ui/app_list/arc/arc_app_icon.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_icon.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/image_decoder.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
+#include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
+#include "chrome/grit/component_extension_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/grit/extensions_browser_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 
 namespace {
 
 bool disable_safe_decoding = false;
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ArcAppIcon::ReadResult
 
 struct ArcAppIcon::ReadResult {
-  enum class Status {
-    OK,
-    FAIL,
-    REQUEST_TO_INSTALL,
-  };
-
-  // Used for fail results or for the requests to install an icon.
-  ReadResult(Status status, ui::ScaleFactor scale_factor)
-      : status(status), scale_factor(scale_factor) {
-    DCHECK(status == Status::FAIL || status == Status::REQUEST_TO_INSTALL);
-  }
-
-  // Used for successful results.
-  ReadResult(ui::ScaleFactor scale_factor,
-             const std::string& unsafe_icon_data)
-      : status(Status::OK),
+  ReadResult(bool error,
+             bool request_to_install,
+             ui::ScaleFactor scale_factor,
+             std::string unsafe_icon_data)
+      : error(error),
+        request_to_install(request_to_install),
         scale_factor(scale_factor),
         unsafe_icon_data(unsafe_icon_data) {
   }
 
-  Status status;
+  bool error;
+  bool request_to_install;
   ui::ScaleFactor scale_factor;
   std::string unsafe_icon_data;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ArcAppIcon::Source
 
 class ArcAppIcon::Source : public gfx::ImageSkiaSource {
  public:
   Source(const base::WeakPtr<ArcAppIcon>& host, int resource_size_in_dip);
@@ skipping 19 matching lines @@
 }
 
 ArcAppIcon::Source::~Source() {
 }
 
 gfx::ImageSkiaRep ArcAppIcon::Source::GetImageForScale(float scale) {
   if (host_)
     host_->LoadForScaleFactor(ui::GetSupportedScaleFactor(scale));
 
   // Host loads icon asynchronously, so use default icon so far.
+  const int resource_id = host_ && host_->app_id() == arc::kPlayStoreAppId ?
+      IDR_ARC_SUPPORT_ICON : IDR_APP_DEFAULT_ICON;
   const gfx::ImageSkia* default_image = ResourceBundle::GetSharedInstance().
-      GetImageSkiaNamed(IDR_APP_DEFAULT_ICON);
+      GetImageSkiaNamed(resource_id);
   CHECK(default_image);
   return gfx::ImageSkiaOperations::CreateResizedImage(
       *default_image,
       skia::ImageOperations::RESIZE_BEST,
       gfx::Size(resource_size_in_dip_, resource_size_in_dip_)).
           GetRepresentation(scale);
 }
 
 class ArcAppIcon::DecodeRequest : public ImageDecoder::ImageRequest {
  public:
@@ skipping 88 matching lines @@
 }
 
 void ArcAppIcon::LoadForScaleFactor(ui::ScaleFactor scale_factor) {
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(context_);
   DCHECK(prefs);
 
   base::FilePath path = prefs->GetIconPath(app_id_, scale_factor);
   if (path.empty())
     return;
 
-  base::PostTaskAndReplyWithResult(content::BrowserThread::GetBlockingPool(),
-                                   FROM_HERE,
-                                   base::Bind(&ArcAppIcon::ReadOnFileThread,
-                                              scale_factor,
-                                              path),
-                                   base::Bind(&ArcAppIcon::OnIconRead,
-                                              weak_ptr_factory_.GetWeakPtr()));
+  base::PostTaskAndReplyWithResult(
+      content::BrowserThread::GetBlockingPool(),
+      FROM_HERE,
+      base::Bind(&ArcAppIcon::ReadOnFileThread,
+          scale_factor,
+          path,
+          prefs->MaybeGetIconPathForDefaultApp(app_id_, scale_factor)),
+      base::Bind(&ArcAppIcon::OnIconRead, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ArcAppIcon::RequestIcon(ui::ScaleFactor scale_factor) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   ArcAppListPrefs* prefs = ArcAppListPrefs::Get(context_);
   DCHECK(prefs);
 
   // ArcAppListPrefs notifies ArcAppModelBuilder via Observer when icon is ready
   // and ArcAppModelBuilder refreshes the icon of the corresponding item by
   // calling LoadScaleFactor.
   prefs->RequestIcon(app_id_, scale_factor);
 }
 
 // static
 std::unique_ptr<ArcAppIcon::ReadResult> ArcAppIcon::ReadOnFileThread(
     ui::ScaleFactor scale_factor,
-    const base::FilePath& path) {
+    const base::FilePath& path,
+    const base::FilePath& default_app_path) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(!path.empty());
 
-  if (!base::PathExists(path))
-    return base::WrapUnique(new ArcAppIcon::ReadResult(
-        ArcAppIcon::ReadResult::Status::REQUEST_TO_INSTALL, scale_factor));
+  base::FilePath path_to_read;
+  if (base::PathExists(path)) {
+    path_to_read = path;
+  } else {
+    if (default_app_path.empty() || !base::PathExists(default_app_path)) {
+      return base::WrapUnique(new ArcAppIcon::ReadResult(
+          false, true, scale_factor, std::string()));
+    }
+    path_to_read = default_app_path;
+  }
 
   // Read the file from disk.
   std::string unsafe_icon_data;
-  if (!base::ReadFileToString(path, &unsafe_icon_data)) {
+  if (!base::ReadFileToString(path_to_read, &unsafe_icon_data)) {
     VLOG(2) << "Failed to read an ARC icon from file " << path.MaybeAsASCII();
     return base::WrapUnique(new ArcAppIcon::ReadResult(
-        ArcAppIcon::ReadResult::Status::FAIL, scale_factor));
+        true, path_to_read != path, scale_factor, std::string()));
   }
 
-  return base::WrapUnique(
-      new ArcAppIcon::ReadResult(scale_factor, unsafe_icon_data));
+  return base::WrapUnique(new ArcAppIcon::ReadResult(false,
+                                                     path_to_read != path,
+                                                     scale_factor,
+                                                     unsafe_icon_data));
 }
 
 void ArcAppIcon::OnIconRead(
     std::unique_ptr<ArcAppIcon::ReadResult> read_result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  switch (read_result->status) {
-  case ReadResult::Status::OK:
+  if (read_result->request_to_install)
+    RequestIcon(read_result->scale_factor);
+
+  if (!read_result->unsafe_icon_data.empty()) {
     decode_requests_.push_back(
         new DecodeRequest(weak_ptr_factory_.GetWeakPtr(),
                           resource_size_in_dip_,
                           read_result->scale_factor));
     if (disable_safe_decoding) {
       SkBitmap bitmap;
       if (!read_result->unsafe_icon_data.empty() &&
           gfx::PNGCodec::Decode(
               reinterpret_cast<const unsigned char*>(
                   &read_result->unsafe_icon_data.front()),
               read_result->unsafe_icon_data.length(),
               &bitmap)) {
         decode_requests_.back()->OnImageDecoded(bitmap);
       } else {
         decode_requests_.back()->OnDecodeImageFailed();
-     }
+      }
     } else {
       ImageDecoder::Start(decode_requests_.back(),
                           read_result->unsafe_icon_data);
     }
-    break;
-  case ReadResult::Status::FAIL:
-    break;
-  case ReadResult::Status::REQUEST_TO_INSTALL:
-    RequestIcon(read_result->scale_factor);
-    break;
-  default:
-    NOTREACHED();
   }
 }
 
 void ArcAppIcon::Update(const gfx::ImageSkia* image) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   CHECK(image && !image->isNull());
 
   std::vector<gfx::ImageSkiaRep> reps = image->image_reps();
   for (const auto& image_rep : reps) {
     if (ui::IsSupportedScale(image_rep.scale())) {
       image_skia_.RemoveRepresentation(image_rep.scale());
       image_skia_.AddRepresentation(image_rep);
     }
   }
 
   image_ = gfx::Image(image_skia_);
 
   observer_->OnIconUpdated(this);
 }
 
 void ArcAppIcon::DiscardDecodeRequest(DecodeRequest* request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   ScopedVector<DecodeRequest>::iterator it = std::find(decode_requests_.begin(),
                                                        decode_requests_.end(),
                                                        request);
   CHECK(it != decode_requests_.end());
   decode_requests_.erase(it);
 }