arc: IPC method to set custom wallpaper.

chrome/browser/chromeos/arc/arc_wallpaper_handler.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 "chrome/browser/chromeos/arc/arc_wallpaper_handler.h"
+
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
+#include "chrome/browser/image_decoder.h"
+#include "components/signin/core/account_id/account_id.h"
+#include "components/user_manager/user_manager.h"
+#include "components/wallpaper/wallpaper_files_id.h"
+#include "components/wallpaper/wallpaper_layout.h"
+#include "ui/gfx/image/image_skia.h"
+
+namespace arc {
+
+namespace {
+
+constexpr char kAndroidWallpaperFilename[] = "android.jpg";
+
+// A thin wrapper of ImageDecoder to decode untrusted JPEG images.
+class UnsafeJpegImageDecoder : public ImageDecoder::ImageRequest {

[hidehiko, 2016/06/16 05:49:24]

This looks just an adapter of from Callback to ImageRequest. Could you make it
so?

class ...Request : public ... ImageRequest {
 public:
  ...Request(const Callback& callback) : callback_(callback) {
  }
   :
 private:
  Callback callback_;
   :
};

[Shuhei Takahashi, 2016/06/16 14:56:10]

With ImageDecoder::Cancel(), I can do this, thanks!

+ public:
+  // Type of the callback function called on image decode completion.
+  // ImageSkia instance can be null value if decoding failed.

[rickyz (no longer on Chrome), 2016/06/16 01:38:48]

Heh, didn't realize this was referring to ImageSkia::isNull, and got confused
for a bit

[Shuhei Takahashi, 2016/06/16 14:56:10]

That's why I wrote null "value" but it might not be very clear yet... Anyway,
this line has been deleted in latest patch.

+  using Callback = base::Callback<void(const gfx::ImageSkia&)>;
+
+  // Starts decoding |jpeg_data| and invokes |callback| on completion.
+  static void Start(const std::vector<uint8_t>& jpeg_data,
+                    const Callback& callback);
+
+  // ImageDecoder::ImageRequest implementation.
+  void OnImageDecoded(const SkBitmap& image) override;
+  void OnDecodeImageFailed() override;
+
+ private:
+  UnsafeJpegImageDecoder(const std::vector<uint8_t>& jpeg_data,
+                         const Callback& callback);
+  ~UnsafeJpegImageDecoder() override = default;
+
+  Callback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(UnsafeJpegImageDecoder);
+};
+
+// static
+void UnsafeJpegImageDecoder::Start(const std::vector<uint8_t>& jpeg_data,
+                                   const Callback& callback) {
+  // Unfortunately ImageDecoder accepts a raw pointer to ImageRequest only,
+  // so callers must not delete ImageRequest instance until decoding finishes.
+  // In our case, let OnImageDecoded/OnDecodeImageFailed delete this
+  // instance on completion.
+  new UnsafeJpegImageDecoder(jpeg_data, callback);

[hidehiko, 2016/06/16 05:49:24]

We should cancel the operation, on the destruction of the ArcWallpaperHandler.

Thus:

class AWHandler : ... {
 public:
  ...
 private:
  std::vector<std::unique_ptr<DecodeImageRequest> > inflight_requests_;
};

AWHandler::~AWHandler() {
  // On UI thread.
  for (DecodeImageRequest* request : inflight_requests_) {
    ImageDecoder::Cancel(request);
  }
}

void SetWallpaper(... data) {
  DecodeImageRequest* request = new Request(base::bind(...));
  inflight_requests_.push_back(request);
  ImageDecoder::StartWithOption(request, ...);
}

... and so on...
Nothen, the life time should be managed by the AWHandler.

[Shuhei Takahashi, 2016/06/16 14:56:10]

Ah I did not notice there is ImageDecoder::Cancel(). Then I can make sure
callbacks are not called after destruction without weak pointers. I've updated
the code to use cancel. It looks much better, thanks!

BTW, I could not use set<unique_ptr> in inflight_requests_ because I can not
execute set::erase() on it. If you know any better way, please let me know.

+}
+
+void UnsafeJpegImageDecoder::OnImageDecoded(const SkBitmap& decoded_image) {
+  // Make the SkBitmap immutable as we won't modify it. This is important
+  // because otherwise it gets duplicated during painting, wasting memory.
+  SkBitmap immutable(decoded_image);
+  immutable.setImmutable();
+  gfx::ImageSkia final_image = gfx::ImageSkia::CreateFrom1xBitmap(immutable);
+  final_image.MakeThreadSafe();
+  callback_.Run(final_image);
+  delete this;
+}
+
+void UnsafeJpegImageDecoder::OnDecodeImageFailed() {
+  callback_.Run(gfx::ImageSkia());
+  delete this;
+}
+
+UnsafeJpegImageDecoder::UnsafeJpegImageDecoder(
+    const std::vector<uint8_t>& jpeg_data,
+    const Callback& callback)
+    : callback_(callback) {
+  std::string jpeg_data_as_string(reinterpret_cast<const char*>(jpeg_data[0]),

[rickyz (no longer on Chrome), 2016/06/16 01:38:48]

Blech, I'm reading through ImageDecoder::StartWithOptions, and the number of
times the image data is copied is disappointing.

Would be nice to send a change to ImageDecoder to get rid of this first copy at
least. The current sequence of copies happening is:

std::vector<uint8_t> -> std::string -> std::vector<unsigned char> ->
mojo::Array<uint8_t>

Which is kind of sad.

[hidehiko, 2016/06/16 05:49:24]

Ah, +1 for :-(. Maybe, we want to fix it separately.

[Shuhei Takahashi, 2016/06/16 14:56:10]

Agreed. I'll leave a TODO here.

+                                  jpeg_data.size());
+  ImageDecoder::StartWithOptions(this, jpeg_data_as_string,
+                                 ImageDecoder::ROBUST_JPEG_CODEC, true);
+}
+
+// Sets a decoded image as the wallpaper.
+void SetImageAsWallpaper(const gfx::ImageSkia& image) {
+  if (image.isNull()) {
+    LOG(ERROR) << "Failed to decode wallpaper image.";
+    return;
+  }
+
+  chromeos::WallpaperManager* wallpaper_manager =
+      chromeos::WallpaperManager::Get();
+
+  const AccountId& account_id =
+      user_manager::UserManager::Get()->GetPrimaryUser()->GetAccountId();
+  wallpaper::WallpaperFilesId wallpaper_files_id =
+      wallpaper_manager->GetFilesId(account_id);
+  bool update_wallpaper =
+      account_id ==
+      user_manager::UserManager::Get()->GetActiveUser()->GetAccountId();
+  // TODO(crbug.com/618922): Allow specifying layout.
+  wallpaper_manager->SetCustomWallpaper(
+      account_id, wallpaper_files_id, kAndroidWallpaperFilename,
+      wallpaper::WALLPAPER_LAYOUT_STRETCH, user_manager::User::CUSTOMIZED,
+      image, update_wallpaper);
+
+  // TODO(crbug.com/618922): Register the wallpaper to Chrome OS wallpaper
+  // picker. Currently the new wallpaper does not appear there. The best way to
+  // make this happen seems to do the same things as wallpaper_api.cc and
+  // wallpaper_private_api.cc.
+}
+
+}  // namespace
+
+void ArcWallpaperHandler::SetWallpaper(const std::vector<uint8_t>& jpeg_data) {
+  UnsafeJpegImageDecoder::Start(jpeg_data, base::Bind(&SetImageAsWallpaper));
+}
+
+}  // namespace arc