Fetch ARC Kiosk app name and icon from Android side.

chrome/browser/chromeos/app_mode/kiosk_app_data_base.cc

+// Copyright 2017 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/chromeos/app_mode/kiosk_app_data_base.h"
+
+#include <utility>
+
+#include "base/files/file_util.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/browser_process.h"
+#include "components/prefs/pref_service.h"
+#include "components/prefs/scoped_user_pref_update.h"
+#include "content/public/browser/browser_thread.h"
+#include "ui/gfx/codec/png_codec.h"
+
+using content::BrowserThread;
+
+namespace chromeos {
+
+namespace {
+
+// Keys for local state data.
+constexpr char kKeyName[] = "name";
+constexpr char kKeyIcon[] = "icon";
+
+// Icon file extension.
+constexpr char kIconFileExtension[] = ".png";
+
+// Save |raw_icon| for given |app_id|.
+void SaveIconToLocalOnBlockingPool(const base::FilePath& icon_path,
+                                   std::vector<unsigned char> image_data) {
+  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+
+  const base::FilePath dir = icon_path.DirName();
+  if (!base::PathExists(dir))
+    DCHECK(base::CreateDirectory(dir));

[xiyuan, 2017/03/30 18:40:08]

DCHECK could a removed for release build and cause base::CreateDirectory not
being called.

If we don't use CHECK, we can do
  if (!base::CreateDirectory(dir)) {
    NOTREACHED();
    return;
  }

But this would cause inconsistency in Local State. We need to handle missing
icon files in such case, or at least adding a ERROR log.

[khmel, 2017/03/30 18:45:47]

I think when we work with FS it is better not force that something is created
and written. Failing to write file is not stopper for Chrome. IMHO having ERROR
logging here is enough. In ARC for example we handle such cases
https://cs.chromium.org/chromium/src/chrome/browser/ui/app_list/arc/arc_app_l...

[Sergey Poromov, 2017/03/31 12:56:24]

Agree about incorrect DCHECK.
I refactored CHECKs here to only LOG errors. I can see the only problem is that
if IO error happens on icon saving, |icon_path_| will have not initialized
value.
But it was the same before as saving icon happened asynchronously with writing
file name to prefs. The difference is LOG error instead of CHECK.
WDYT, is the change correct?

+
+  CHECK_EQ(

[Luis Héctor Chávez, 2017/03/30 19:57:22]

Please remove all CHECKs from this change.

[Sergey Poromov, 2017/03/31 12:56:25]

Done. Is changing to LOG(ERROR) and return after sufficient for the cases here?

[Luis Héctor Chávez, 2017/04/03 22:58:55]

I believe so, I don't think we can do anything else.

+      static_cast<int>(image_data.size()),
+      base::WriteFile(icon_path, reinterpret_cast<char*>(image_data.data()),
+                      image_data.size()));
+}
+
+}  // namespace
+
+// static
+const char KioskAppDataBase::kKeyApps[] = "apps";
+
+KioskAppDataBase::KioskAppDataBase(const std::string& dictionary_name,
+                                   const std::string& app_id,
+                                   const AccountId& account_id)
+    : dictionary_name_(dictionary_name),
+      app_id_(app_id),
+      account_id_(account_id),
+      weak_factory_(this) {}
+
+KioskAppDataBase::~KioskAppDataBase() = default;
+
+void KioskAppDataBase::SaveToDictionary(DictionaryPrefUpdate& dict_update) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  const std::string app_key = std::string(kKeyApps) + '.' + app_id_;
+  const std::string name_key = app_key + '.' + kKeyName;
+  const std::string icon_path_key = app_key + '.' + kKeyIcon;
+
+  dict_update->SetString(name_key, name_);
+  dict_update->SetString(icon_path_key, icon_path_.value());
+}
+
+bool KioskAppDataBase::LoadFromDictionary(const base::DictionaryValue* dict) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  const std::string app_key =
+      std::string(KioskAppDataBase::kKeyApps) + '.' + app_id_;
+  const std::string name_key = app_key + '.' + kKeyName;
+  const std::string icon_path_key = app_key + '.' + kKeyIcon;
+
+  std::string icon_path_string;
+  if (!dict->GetString(name_key, &name_) ||
+      !dict->GetString(icon_path_key, &icon_path_string)) {
+    return false;
+  }
+  icon_path_ = base::FilePath(icon_path_string);
+
+  // KioskAppIconLoader deletes itself when done.
+  (new KioskAppIconLoader(weak_factory_.GetWeakPtr()))->Start(icon_path_);
+  return true;
+}
+
+void KioskAppDataBase::SaveIcon(const SkBitmap& icon,
+                                const base::FilePath& cache_dir) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  std::vector<unsigned char> image_data;
+  CHECK(gfx::PNGCodec::EncodeBGRASkBitmap(icon, false, &image_data));
+
+  base::FilePath icon_path =
+      cache_dir.AppendASCII(app_id_).AddExtension(kIconFileExtension);
+  BrowserThread::GetBlockingPool()->PostTask(
+      FROM_HERE, base::Bind(&SaveIconToLocalOnBlockingPool, icon_path,
+                            base::Passed(std::move(image_data))));
+
+  icon_path_ = icon_path;
+}
+
+void KioskAppDataBase::ClearCache() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  PrefService* local_state = g_browser_process->local_state();
+
+  DictionaryPrefUpdate dict_update(local_state, dictionary_name());
+
+  std::string app_key = std::string(KioskAppDataBase::kKeyApps) + '.' + app_id_;
+  dict_update->Remove(app_key, nullptr);
+
+  if (!icon_path_.empty()) {
+    base::PostTaskWithTraits(
+        FROM_HERE,
+        base::TaskTraits().MayBlock().WithPriority(
+            base::TaskPriority::BACKGROUND),
+        base::Bind(base::IgnoreResult(&base::DeleteFile), icon_path_, false));
+  }
+}
+
+}  // namespace chromeos