Fetch ARC Kiosk app name and icon from Android side.

chrome/browser/chromeos/app_mode/kiosk_app_icon_loader.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_icon_loader.h"
+
+#include <vector>
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "chrome/browser/image_decoder.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
+
+namespace chromeos {
+
+class KioskAppIconLoader::IconImageRequest : public ImageDecoder::ImageRequest {
+ public:
+  IconImageRequest(const scoped_refptr<base::SequencedTaskRunner>& task_runner,
+                   KioskAppIconLoader* icon_loader)
+      : ImageRequest(task_runner), icon_loader_(icon_loader) {}
+
+  void OnImageDecoded(const SkBitmap& decoded_image) override {
+    icon_loader_->icon_ = gfx::ImageSkia::CreateFrom1xBitmap(decoded_image);
+    icon_loader_->icon_.MakeThreadSafe();
+    icon_loader_->ReportResultOnBlockingPool(SUCCESS);
+    delete this;
+  }
+
+  void OnDecodeImageFailed() override {
+    icon_loader_->ReportResultOnBlockingPool(FAILED_TO_DECODE);
+    delete this;
+  }
+
+ private:
+  ~IconImageRequest() override = default;
+  KioskAppIconLoader* const icon_loader_;
+};
+
+KioskAppIconLoader::KioskAppIconLoader(Delegate* delegate)
+    : delegate_(delegate), weak_factory_(this) {}
+
+KioskAppIconLoader::~KioskAppIconLoader() = default;
+
+void KioskAppIconLoader::Start(const base::FilePath& icon_path) {
+  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
+  base::SequencedWorkerPool::SequenceToken token = pool->GetSequenceToken();
+  task_runner_ = pool->GetSequencedTaskRunnerWithShutdownBehavior(
+      token, base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  task_runner_->PostTask(FROM_HERE,

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

Sorry, should have been a bit clearer here. There's still a bit of a problem in
this code because you are accessing "this" racily on two threads: the UI thread
and the blocking pool. Would it be possible to not access "this" on the blocking
pool at all? i.e.

task_runner_->PostTask(FROM_HERE,
                       base::Bind(LoadOnBlockingPool, icon_path, task_runner_));

..

void LoadOnBlockingPool(const base::FilePath& icon_path, XxxCallback
success_callback, XxxCallback error_callback,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner) {
  ...

  // IconImageRequest will delete itself on completion of ImageDecoder callback.
  IconImageRequest* image_request = new IconImageRequest(callback_task_runner,
success_callback, error_callback);
  ImageDecoder::Start(image_request,
                      std::vector<uint8_t>(data.begin(), data.end()));
}

and then in the KioskAppIconLoader::IconImageRequest instead of calling
ReportResultOnBlockingPool, you can directly do

  callback_task_runner_->PostTask(FROM_HERE, base::Bind(success_callback_,
decoded_icon));

  or

  callback_task_runner_->PostTask(FROM_HERE, base::Bind(error_callback_,
FAILED_TO_DECODE));

Then again, it does not look like you're using the result at all, so you might
was well just have a single function

void KioskAppIconLoader::OnImageDecodingFinished(base::Optional<gfx::ImageSkia>
result) {
  DCHECK_CURRENTLY_ON(BrowserThread::UI);

  if (result.has_value()) {
    delegate_->OnIconLoadSuccess(std::move(result.value()));
  } else {
    delegate_->OnIconLoadFailure();
  }
}

and then add logging statements where you actually encountered the failure
(either in L63 or in L34).

[Sergey Poromov, 2017/04/06 10:29:58]

Done. Please check that I did it right.
Also, I can't do manual test until next week - PatchSet 10 is the last tested,
but now this PS differs a lot, so I'll probably wait until next week to land.

+                         base::Bind(&KioskAppIconLoader::LoadOnBlockingPool,
+                                    weak_factory_.GetWeakPtr(), icon_path));
+}
+
+void KioskAppIconLoader::LoadOnBlockingPool(const base::FilePath& icon_path) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  std::string data;
+  if (!base::ReadFileToString(base::FilePath(icon_path), &data)) {
+    ReportResultOnBlockingPool(FAILED_TO_LOAD);
+    return;
+  }
+
+  // IconImageRequest will delete itself on completion of ImageDecoder callback.
+  IconImageRequest* image_request = new IconImageRequest(task_runner_, this);
+  ImageDecoder::Start(image_request,
+                      std::vector<uint8_t>(data.begin(), data.end()));
+}
+
+void KioskAppIconLoader::ReportResultOnBlockingPool(LoadResult result) {
+  DCHECK(task_runner_->RunsTasksOnCurrentThread());
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&KioskAppIconLoader::ReportResultOnUIThread,
+                 weak_factory_.GetWeakPtr(), result));
+}
+
+void KioskAppIconLoader::NotifyDelegate(LoadResult result) {
+  if (result == SUCCESS)
+    delegate_->OnIconLoadSuccess(icon_);
+  else
+    delegate_->OnIconLoadFailure();
+}
+
+void KioskAppIconLoader::ReportResultOnUIThread(LoadResult result) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  NotifyDelegate(result);
+}
+
+}  // namespace chromeos