arc: IPC method to set custom wallpaper.

components/arc/intent_helper/arc_intent_helper_bridge.cc

 // Copyright 2016 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 "components/arc/intent_helper/arc_intent_helper_bridge.h"
 
+#include <memory>
+#include <utility>
 #include <vector>
 
 #include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/new_window_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
+#include "base/bind.h"
 #include "base/memory/weak_ptr.h"
+#include "base/task_runner_util.h"
 #include "components/arc/intent_helper/activity_icon_loader.h"
 #include "components/arc/intent_helper/link_handler_model_impl.h"
+#include "components/arc/set_wallpaper_delegate.h"
 #include "ui/base/layout.h"
+#include "ui/gfx/codec/jpeg_codec.h"
 #include "url/gurl.h"
 
 namespace arc {
 
+namespace {
+
+gfx::ImageSkia DecodeJpegImage(mojo::Array<uint8_t> jpeg_data) {
+  std::unique_ptr<SkBitmap> bitmap = gfx::JPEGCodec::Decode(

[Yusuke Sato, 2016/06/15 16:12:49]

qq: Is it safe/allowed to decode an arbitrary jpeg file from ARC in the browser
process? app.mojom's host implementation uses chrome/browser/image_decoder.h to
decode pngs in the utility process.

[Shuhei Takahashi, 2016/06/15 18:14:37]

Good point, maybe we must use ImageDecoder instead.

Since components/arc can not depend on chrome/browser/image_decoder, I moved all
decoding logic into arc_wallpaper_handler.

+      static_cast<const unsigned char*>(&jpeg_data.storage()[0]),
+      jpeg_data.size());
+  bitmap->setImmutable();
+  gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(*bitmap);
+  image.MakeThreadSafe();
+  return std::move(image);
+}
+
+}  // namespace
+
 ArcIntentHelperBridge::ArcIntentHelperBridge(
     ArcBridgeService* bridge_service,
-    const scoped_refptr<ActivityIconLoader>& icon_loader)
-    : ArcService(bridge_service), binding_(this), icon_loader_(icon_loader) {
+    const scoped_refptr<ActivityIconLoader>& icon_loader,
+    const scoped_refptr<base::TaskRunner>& blocking_task_runner,
+    std::unique_ptr<SetWallpaperDelegate> set_wallpaper_delegate)
+    : ArcService(bridge_service),
+      binding_(this),
+      icon_loader_(icon_loader),
+      blocking_task_runner_(blocking_task_runner),
+      set_wallpaper_delegate_(std::move(set_wallpaper_delegate)),
+      weak_factory_(this) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   arc_bridge_service()->AddObserver(this);
 }
 
 ArcIntentHelperBridge::~ArcIntentHelperBridge() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   arc_bridge_service()->RemoveObserver(this);
 }
 
 void ArcIntentHelperBridge::OnIntentHelperInstanceReady() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   ash::Shell::GetInstance()->set_link_handler_model_factory(this);
   arc_bridge_service()->intent_helper_instance()->Init(
       binding_.CreateInterfacePtrAndBind());
 }
 
 void ArcIntentHelperBridge::OnIntentHelperInstanceClosed() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   ash::Shell::GetInstance()->set_link_handler_model_factory(nullptr);
 }
 
 void ArcIntentHelperBridge::OnIconInvalidated(
     const mojo::String& package_name) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   icon_loader_->InvalidateIcons(package_name);
 }
 
 void ArcIntentHelperBridge::OnOpenDownloads() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(607411): If the FileManager is not yet open this will open to
   // downloads by default, which is what we want.  However if it is open it will
   // simply be brought to the forgeground without forcibly being navigated to
   // downloads, which is probably not ideal.
   ash::Shell::GetInstance()->new_window_delegate()->OpenFileManager();
 }
 
 void ArcIntentHelperBridge::OnOpenUrl(const mojo::String& url) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   GURL gurl(url.get());
   ash::Shell::GetInstance()->delegate()->OpenUrl(gurl);
 }
 
 void ArcIntentHelperBridge::OpenWallpaperPicker() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   ash::Shell::GetInstance()->user_wallpaper_delegate()->OpenSetWallpaperPage();
 }
 
+void ArcIntentHelperBridge::SetWallpaper(mojo::Array<uint8_t> jpeg_data) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  base::PostTaskAndReplyWithResult(
+      blocking_task_runner_.get(), FROM_HERE,
+      base::Bind(&DecodeJpegImage, base::Passed(std::move(jpeg_data))),
+      base::Bind(&ArcIntentHelperBridge::SetImageAsWallpaper,
+                 weak_factory_.GetWeakPtr()));
+}
+
 std::unique_ptr<ash::LinkHandlerModel> ArcIntentHelperBridge::CreateModel(
     const GURL& url) {
   std::unique_ptr<LinkHandlerModelImpl> impl(

[Yusuke Sato, 2016/06/15 16:45:01]

You can add the same DCHECK here if you want. It's called only on the UI thread.

[Shuhei Takahashi, 2016/06/15 18:14:37]

Done.

       new LinkHandlerModelImpl(icon_loader_));
   if (!impl->Init(url))
     return nullptr;
   return std::move(impl);
 }
 
+void ArcIntentHelperBridge::SetImageAsWallpaper(gfx::ImageSkia image) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  set_wallpaper_delegate_->SetWallpaper(image);
+}
+
 }  // namespace arc