Hook up Chrome's wallpaper picker for mash.

ash/sysui/sysui_application.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 "ash/sysui/sysui_application.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "ash/common/shell_window_ids.h"
 #include "ash/desktop_background/desktop_background_controller.h"
+#include "ash/display/display_manager.h"
 #include "ash/host/ash_window_tree_host_init_params.h"
 #include "ash/host/ash_window_tree_host_platform.h"
 #include "ash/material_design/material_design_controller.h"
 #include "ash/public/interfaces/ash_window_type.mojom.h"
 #include "ash/public/interfaces/container.mojom.h"
 #include "ash/root_window_settings.h"
 #include "ash/shell.h"
 #include "ash/shell_init_params.h"
 #include "ash/sysui/app_list_presenter_mus.h"
 #include "ash/sysui/keyboard_ui_mus.h"
 #include "ash/sysui/shelf_delegate_mus.h"
 #include "ash/sysui/shell_delegate_mus.h"
 #include "ash/sysui/stub_context_factory.h"
+#include "ash/sysui/user_wallpaper_delegate_mus.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "services/catalog/public/cpp/resource_loader.h"
 #include "services/shell/public/cpp/connector.h"
 #include "ui/aura/env.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_paths.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/message_center/message_center.h"
 #include "ui/platform_window/stub/stub_window.h"
 #include "ui/views/mus/aura_init.h"
 #include "ui/views/mus/native_widget_mus.h"
 #include "ui/views/mus/window_manager_connection.h"
 #include "ui/views/views_delegate.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "ui/events/devices/device_data_manager.h"
 #endif
 
 using views::ViewsDelegate;
 
 namespace ash {
 namespace sysui {
 
 namespace {
 
 const char kResourceFileStrings[] = "ash_resources_strings.pak";
 const char kResourceFile100[] = "ash_resources_100_percent.pak";
 const char kResourceFile200[] = "ash_resources_200_percent.pak";
 
 // Tries to determine the corresponding mash container from widget init params.
-mojom::Container GetContainerId(const views::Widget::InitParams& params) {
+ash::mojom::Container GetContainerId(const views::Widget::InitParams& params) {
   const int id = params.parent->id();
   if (id == kShellWindowId_DesktopBackgroundContainer)
-    return mojom::Container::USER_BACKGROUND;
+    return ash::mojom::Container::USER_BACKGROUND;
   if (id == kShellWindowId_ShelfContainer)
-    return mojom::Container::USER_PRIVATE_SHELF;
+    return ash::mojom::Container::USER_PRIVATE_SHELF;
   if (id == kShellWindowId_StatusContainer)
-    return mojom::Container::STATUS;
+    return ash::mojom::Container::STATUS;
 
   // Determine the container based on Widget type.
   switch (params.type) {
     case views::Widget::InitParams::Type::TYPE_BUBBLE:
-      return mojom::Container::BUBBLES;
+      return ash::mojom::Container::BUBBLES;
     case views::Widget::InitParams::Type::TYPE_MENU:
-      return mojom::Container::MENUS;
+      return ash::mojom::Container::MENUS;
     case views::Widget::InitParams::Type::TYPE_TOOLTIP:
-      return mojom::Container::DRAG_AND_TOOLTIPS;
+      return ash::mojom::Container::DRAG_AND_TOOLTIPS;
     default:
-      return mojom::Container::COUNT;
+      return ash::mojom::Container::COUNT;
   }
 }
 
 // Tries to determine the corresponding ash window type from the ash container
 // for the widget.
-mojom::AshWindowType GetAshWindowType(aura::Window* container) {
+ash::mojom::AshWindowType GetAshWindowType(aura::Window* container) {
   DCHECK(container);
   int id = container->id();
   if (id == kShellWindowId_ShelfContainer)
-    return mojom::AshWindowType::SHELF;
+    return ash::mojom::AshWindowType::SHELF;
   if (id == kShellWindowId_StatusContainer)
-    return mojom::AshWindowType::STATUS_AREA;
-  return mojom::AshWindowType::COUNT;
+    return ash::mojom::AshWindowType::STATUS_AREA;
+  return ash::mojom::AshWindowType::COUNT;
 }
 
 // Creates a StubWindow, which means this window never receives any input event,
 // or displays anything to the user.
 class AshWindowTreeHostMus : public AshWindowTreeHostPlatform {
  public:
   explicit AshWindowTreeHostMus(const gfx::Rect& initial_bounds)
       : AshWindowTreeHostPlatform() {
     std::unique_ptr<ui::PlatformWindow> window(new ui::StubWindow(this));
     window->SetBounds(initial_bounds);
@@ skipping 28 matching lines @@
     ViewsDelegate::GetInstance()->set_native_widget_factory(
         ViewsDelegate::NativeWidgetFactory());
   }
 
  private:
   views::NativeWidget* InitNativeWidget(
       const views::Widget::InitParams& params,
       views::internal::NativeWidgetDelegate* delegate) {
     std::map<std::string, std::vector<uint8_t>> properties;
     if (params.parent) {
-      mojom::Container container = GetContainerId(params);
-      if (container != mojom::Container::COUNT) {
-        properties[mojom::kWindowContainer_Property] =
+      ash::mojom::Container container = GetContainerId(params);
+      if (container != ash::mojom::Container::COUNT) {
+        properties[ash::mojom::kWindowContainer_Property] =
             mojo::ConvertTo<std::vector<uint8_t>>(
                 static_cast<int32_t>(container));
       }
-      mojom::AshWindowType type = GetAshWindowType(params.parent);
-      if (type != mojom::AshWindowType::COUNT) {
-        properties[mojom::kAshWindowType_Property] =
+      ash::mojom::AshWindowType type = GetAshWindowType(params.parent);
+      if (type != ash::mojom::AshWindowType::COUNT) {
+        properties[ash::mojom::kAshWindowType_Property] =
             mojo::ConvertTo<std::vector<uint8_t>>(static_cast<int32_t>(type));
       }
     }
 
     // AshInit installs a stub implementation of ui::ContextFactory, so that the
     // AshWindowTreeHost instances created do not actually show anything to the
     // user. However, when creating a views::Widget instance, the
     // WindowManagerConnection creates a WindowTreeHostMus instance, which
     // creates a ui::Compositor, and it needs a real ui::ContextFactory
     // implementation. So, unset the context-factory here temporarily when
@@ skipping 66 matching lines @@
     init_params.context_factory = new StubContextFactory;
     init_params.blocking_pool = worker_pool_.get();
     init_params.in_mus = true;
     init_params.keyboard_factory =
         base::Bind(&KeyboardUIMus::Create, connector);
     Shell::CreateInstance(init_params);
     Shell::GetInstance()->CreateShelf();
     Shell::GetInstance()->UpdateAfterLoginStatusChange(user::LOGGED_IN_USER);
 
     Shell::GetPrimaryRootWindow()->GetHost()->Show();
-    SetupWallpaper(SkColorSetARGB(255, 0, 255, 0));
   }
 
   void InitializeResourceBundle(::shell::Connector* connector) {
     if (ui::ResourceBundle::HasSharedInstance())
       return;
 
     std::set<std::string> resource_paths;
     resource_paths.insert(kResourceFileStrings);
     resource_paths.insert(kResourceFile100);
     resource_paths.insert(kResourceFile200);
 
     catalog::ResourceLoader loader;
     filesystem::mojom::DirectoryPtr directory;
     connector->ConnectToInterface("mojo:catalog", &directory);
     CHECK(loader.OpenFiles(std::move(directory), resource_paths));
 
     // Load ash resources and en-US strings; not 'common' (Chrome) resources.
     // TODO(msw): Check ResourceBundle::IsScaleFactorSupported; load 300% etc.
     ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(
         loader.TakeFile(kResourceFileStrings),
         base::MemoryMappedFile::Region::kWholeFile);
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     rb.AddDataPackFromFile(loader.TakeFile(kResourceFile100),
                            ui::SCALE_FACTOR_100P);
     rb.AddDataPackFromFile(loader.TakeFile(kResourceFile200),
                            ui::SCALE_FACTOR_200P);
   }
 
-  void SetupWallpaper(SkColor color) {
-    SkBitmap bitmap;
-    bitmap.allocN32Pixels(16, 16);
-    bitmap.eraseColor(color);
-#if !defined(NDEBUG)
-    // In debug builds we generate a simple pattern that allows visually
-    // notice if transparency is broken.
-    {
-      SkAutoLockPixels alp(bitmap);
-      *bitmap.getAddr32(0, 0) = SkColorSetRGB(0, 0, 0);
-    }
-#endif
-    gfx::ImageSkia wallpaper = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
-    Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
-        wallpaper, wallpaper::WALLPAPER_LAYOUT_TILE);
-  }
-
   void InitializeComponents() {
     message_center::MessageCenter::Initialize();
 
 #if defined(OS_CHROMEOS)
     ui::DeviceDataManager::CreateInstance();
     chromeos::DBusThreadManager::Initialize();
     bluez::BluezDBusManager::Initialize(
         chromeos::DBusThreadManager::Get()->GetSystemBus(),
         chromeos::DBusThreadManager::Get()->IsUsingStub(
             chromeos::DBusClientBundle::BLUETOOTH));
@@ skipping 16 matching lines @@
 
 void SysUIApplication::Initialize(::shell::Connector* connector,
                                   const ::shell::Identity& identity,
                                   uint32_t id) {
   ash_init_.reset(new AshInit());
   ash_init_->Initialize(connector, identity);
 }
 
 bool SysUIApplication::AcceptConnection(::shell::Connection* connection) {
   connection->AddInterface<mash::shelf::mojom::ShelfController>(this);
+  connection->AddInterface<mojom::WallpaperController>(this);
   return true;
 }
 
 void SysUIApplication::Create(
     ::shell::Connection* connection,
-    mojo::InterfaceRequest<mash::shelf::mojom::ShelfController> request) {
+    mash::shelf::mojom::ShelfControllerRequest request) {
   mash::shelf::mojom::ShelfController* shelf_controller =
       static_cast<ShelfDelegateMus*>(Shell::GetInstance()->GetShelfDelegate());
   shelf_controller_bindings_.AddBinding(shelf_controller, std::move(request));
 }
 
+void SysUIApplication::Create(::shell::Connection* connection,
+                              mojom::WallpaperControllerRequest request) {
+  mojom::WallpaperController* wallpaper_controller =
+      static_cast<UserWallpaperDelegateMus*>(
+          Shell::GetInstance()->user_wallpaper_delegate());
+  wallpaper_controller_bindings_.AddBinding(wallpaper_controller,
+                                            std::move(request));
+}
+
 }  // namespace sysui
 }  // namespace ash