Hook up Chrome's wallpaper picker for mash.

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc

 // Copyright 2014 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/login/users/wallpaper/wallpaper_manager.h"
 
 #include <stdint.h>
 #include <numeric>
 #include <utility>
 #include <vector>
@@ skipping 18 matching lines @@
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/customization/customization_document.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/ui/ash/ash_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/user_names.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/known_user.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_image/user_image.h"
 #include "components/user_manager/user_manager.h"
 #include "components/user_manager/user_type.h"
 #include "components/wallpaper/wallpaper_files_id.h"
 #include "components/wallpaper/wallpaper_layout.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/mojo_shell_connection.h"
+#include "services/shell/public/cpp/connector.h"
+#include "skia/public/type_converters.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skia_util.h"
 
+#if defined(MOJO_SHELL_CLIENT)
+#include "ash/mus/public/interfaces/wallpaper.mojom.h"
+#endif
+
 using content::BrowserThread;
 using wallpaper::WallpaperManagerBase;
 using wallpaper::WallpaperInfo;
 using wallpaper::MovableOnDestroyCallback;
 using wallpaper::MovableOnDestroyCallbackHolder;
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 90 matching lines @@
   return wallpaper::WallpaperFilesId::FromString(result);
 }
 
 void SetKnownUserWallpaperFilesId(
     const AccountId& account_id,
     const wallpaper::WallpaperFilesId& wallpaper_files_id) {
   user_manager::known_user::SetStringPref(account_id, kWallpaperFilesId,
                                           wallpaper_files_id.id());
 }
 
+// A helper to set the wallpaper image for Ash and Mash.
+void SetWallpaper(const gfx::ImageSkia& image,
+                  wallpaper::WallpaperLayout layout) {
+#if defined(MOJO_SHELL_CLIENT)
+  if (chrome::IsRunningInMash()) {
+    shell::Connector* connector =
+        content::MojoShellConnection::Get()->GetConnector();
+    ash::mus::mojom::WallpaperControllerPtr wallpaper_controller;
+    connector->ConnectToInterface("mojo:ash_sysui", &wallpaper_controller);
+    wallpaper_controller->SetWallpaper(
+        skia::mojom::Bitmap::From(*image.bitmap()),

[dcheng, 2016/05/24 18:53:37]

Can we do this with a StructTraits instead? My worry about adding further
dependencies on the existing TypeConverter is that it's going to make it harder
to remove down the road.

[msw, 2016/05/24 22:06:37]

Yeah, Yuzhu gave me an intro to StructTraits, and it definitely seems possible.
Since I'm not adding a new type converter, but just making use of an existing
one, I wonder if it's necessary for this CL. Would you like me to add struct
traits and remove all existing skia bitmap type conversion uses and the
converter itself: (1) separately as a prerequisite to this CL, (2) done as part
of this CL (I hope not) or (3) left for a follow-up change?

[dcheng, 2016/05/25 17:31:26]

We can add the StructTraits without removing all uses of the old one in this CL,
I think. That way, we can start incremental migration over.

[msw, 2016/05/25 18:16:41]

I'd rather not pollute this wallpaper CL with the addition of skia bitmap
StructTraits. I'll put this CL on hold and implement that in a separate
prerequisite CL if you think it's a blocker.

[dcheng, 2016/05/25 19:56:40]

I'd strongly prefer to see that. I thought it'd be easier since this CL would be
defacto proof that the StructTraits works, but if you feel it would be better in
a separate CL, that's fine with me.

+        static_cast<ash::mus::mojom::WallpaperLayout>(layout));

[dcheng, 2016/05/24 18:53:37]

Similarly, do StructTraits work for enums yet?

[yzshen1, 2016/05/24 22:04:42]

Yes. For example:

module mojom;
enum SomeEnum {};
struct Foo {
  SomeEnum value;
};

The struct traits will be:

template<>
class StructTraits<mojom::Foo, CustomFoo> {
  // The getter of an enum field needs to return the exact mojo enum type.
  static mojom::SomeEnum value(const CustomFoo& input) {
    ...
  }
};

[msw, 2016/05/24 22:06:37]

We can support enums within a struct, but I don't think we have EnumTraits or
similar, let me know if there's some other approach you suggest.

[msw, 2016/05/24 22:06:37]

Right, but in this case, I'm passing an enum value to a mojom function, not
encapsulating it within a struct...

[dcheng, 2016/05/25 19:56:40]

and maybe in the meantime we can figure out something better for this? How does
StructTraits handle nested mojo structs, for example?

+    return;
+  }
+#endif
+  // Avoid loading unnecessary wallpapers in tests without a shell instance.
+  if (ash::Shell::HasInstance()) {
+    ash::Shell::GetInstance()
+        ->desktop_background_controller()
+        ->SetWallpaperImage(image, layout);
+  }
+}
+
 }  // namespace
 
 // This is "wallpaper either scheduled to load, or loading right now".
 //
 // While enqueued, it defines moment in the future, when it will be loaded.
 // Enqueued but not started request might be updated by subsequent load
 // request. Therefore it's created empty, and updated being enqueued.
 //
 // PendingWallpaper is owned by WallpaperManager, but reference to this object
 // is passed to other threads by PostTask() calls, therefore it is
@@ skipping 10 matching lines @@
                        this))) {
     timer.Start(
         FROM_HERE,
         delay,
         base::Bind(&WallpaperManager::PendingWallpaper::ProcessRequest, this));
   }
 
   // There are 4 cases in SetUserWallpaper:
   // 1) gfx::ImageSkia is found in cache.
   //    - Schedule task to (probably) resize it and install:
-  //    call ash::Shell::GetInstance()->desktop_background_controller()->
-  //          SetCustomWallpaper(user_wallpaper, layout);
+  //    call SetWallpaper(user_wallpaper, layout);
   // 2) WallpaperInfo is found in cache
   //    - need to LoadWallpaper(), resize and install.
   // 3) wallpaper path is not NULL, load image URL, then resize, etc...
   // 4) SetDefaultWallpaper (either on some error, or when user is new).
   void ResetSetWallpaperImage(const gfx::ImageSkia& image,
                               const wallpaper::WallpaperInfo& info) {
     SetMode(image, info, base::FilePath(), false);
   }
 
   void ResetLoadWallpaper(const wallpaper::WallpaperInfo& info) {
@@ skipping 33 matching lines @@
 
     WallpaperManager* manager = WallpaperManager::Get();
     if (manager->pending_inactive_ == this)
       manager->pending_inactive_ = NULL;
 
     started_load_at_ = base::Time::Now();
 
     if (default_) {
       manager->DoSetDefaultWallpaper(account_id_, std::move(on_finish_));
     } else if (!user_wallpaper_.isNull()) {
-      ash::Shell::GetInstance()
-          ->desktop_background_controller()
-          ->SetWallpaperImage(user_wallpaper_, info_.layout);
+      SetWallpaper(user_wallpaper_, info_.layout);
     } else if (!wallpaper_path_.empty()) {
       manager->task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal, account_id_,
                      info_, wallpaper_path_, true /* update wallpaper */,
                      base::ThreadTaskRunnerHandle::Get(),
                      base::Passed(std::move(on_finish_)),
                      manager->weak_factory_.GetWeakPtr()));
     } else if (!info_.location.empty()) {
       manager->LoadWallpaper(account_id_, info_, true, std::move(on_finish_));
@@ skipping 318 matching lines @@
   GetPendingWallpaper(account_id, true)->ResetSetDefaultWallpaper();
 }
 
 void WallpaperManager::DoSetDefaultWallpaper(
     const AccountId& account_id,
     MovableOnDestroyCallbackHolder on_finish) {
   // There is no visible background in kiosk mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   wallpaper_cache_.erase(account_id);
-  // Some browser tests do not have a shell instance. As no wallpaper is needed
-  // in these tests anyway, avoid loading one, preventing crashes and speeding
-  // up the tests.
-  if (!ash::Shell::HasInstance())
-    return;
 
   WallpaperResolution resolution = GetAppropriateResolution();
   const bool use_small = (resolution == WALLPAPER_RESOLUTION_SMALL);
 
   const base::FilePath* file = NULL;
 
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(account_id);
 
   if (user_manager::UserManager::Get()->IsLoggedInAsGuest()) {
@@ skipping 20 matching lines @@
       return;
     }
 
     CreateSolidDefaultWallpaper();
   }
   // 1x1 wallpaper is actually solid color, so it should be stretched.
   if (default_wallpaper_image_->image().width() == 1 &&
       default_wallpaper_image_->image().height() == 1)
     layout = wallpaper::WALLPAPER_LAYOUT_STRETCH;
 
-  ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
-      default_wallpaper_image_->image(), layout);
+  SetWallpaper(default_wallpaper_image_->image(), layout);
 }
 
 void WallpaperManager::SetUserWallpaperInfo(const AccountId& account_id,
                                             const WallpaperInfo& info,
                                             bool is_persistent) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   current_user_wallpaper_info_ = info;
   if (!is_persistent)
     return;
 
@@ skipping 294 matching lines @@
     SetUserWallpaperInfo(account_id, info, true);
 
     if (update_wallpaper)
       DoSetDefaultWallpaper(account_id, std::move(on_finish));
     return;
   }
 
   // Update the image, but keep the path which was set earlier.
   wallpaper_cache_[account_id].second = user_image->image();
 
-  if (update_wallpaper) {
-    ash::Shell::GetInstance()
-        ->desktop_background_controller()
-        ->SetWallpaperImage(user_image->image(), layout);
-  }
+  if (update_wallpaper)
+    SetWallpaper(user_image->image(), layout);
 }
 
 void WallpaperManager::StartLoad(const AccountId& account_id,
                                  const WallpaperInfo& info,
                                  bool update_wallpaper,
                                  const base::FilePath& wallpaper_path,
                                  MovableOnDestroyCallbackHolder on_finish) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT_ASYNC_BEGIN0("ui", "LoadAndDecodeWallpaper", this);
   if (update_wallpaper) {
@@ skipping 84 matching lines @@
   default_wallpaper_image_.reset();
 }
 
 void WallpaperManager::OnDefaultWallpaperDecoded(
     const base::FilePath& path,
     const wallpaper::WallpaperLayout layout,
     std::unique_ptr<user_manager::UserImage>* result_out,
     MovableOnDestroyCallbackHolder on_finish,
     std::unique_ptr<user_manager::UserImage> user_image) {
   *result_out = std::move(user_image);
-  ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
-      (*result_out)->image(), layout);
+  SetWallpaper((*result_out)->image(), layout);
 }
 
 void WallpaperManager::StartLoadAndSetDefaultWallpaper(
     const base::FilePath& path,
     const wallpaper::WallpaperLayout layout,
     MovableOnDestroyCallbackHolder on_finish,
     std::unique_ptr<user_manager::UserImage>* result_out) {
   user_image_loader::StartWithFilePath(
       task_runner_, path, ImageDecoder::ROBUST_JPEG_CODEC,
       0,  // Do not crop.
@@ skipping 52 matching lines @@
                                               &stored_value)) {
     return wallpaper::WallpaperFilesId::FromString(stored_value);
   }
   const std::string& old_id = account_id.GetUserEmail();  // Migrated
   const wallpaper::WallpaperFilesId files_id = HashWallpaperFilesIdStr(old_id);
   SetKnownUserWallpaperFilesId(account_id, files_id);
   return files_id;
 }
 
 }  // namespace chromeos