Add SkBitmap StructTraits for skia::mojo::Bitmap.

ash/sysui/shelf_delegate_mus.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/shelf_delegate_mus.h"
 
 #include <memory>
 
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_item_delegate.h"
 #include "ash/shelf/shelf_item_delegate_manager.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_menu_model.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "base/strings/string_util.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "mojo/common/common_type_converters.h"
 #include "services/shell/public/cpp/connector.h"
-#include "skia/public/type_converters.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/mus/window_manager_connection.h"
 
 using mash::wm::mojom::UserWindowController;
 
 namespace ash {
 namespace sysui {
@@ skipping 273 matching lines @@
     return;
   }
 
   ShelfID shelf_id = model_->next_id();
   app_id_to_shelf_id_.insert(std::make_pair(app_id, shelf_id));
   shelf_id_to_app_id_.insert(std::make_pair(shelf_id, app_id));
 
   ShelfItem shelf_item;
   shelf_item.type = TYPE_APP_SHORTCUT;
   shelf_item.status = STATUS_CLOSED;
-  shelf_item.image = GetShelfIconFromBitmap(item->image.To<SkBitmap>());
+  shelf_item.image = GetShelfIconFromBitmap(item->image);
   model_->Add(shelf_item);
 
   std::unique_ptr<ShelfItemDelegateMus> item_delegate(
       new ShelfItemDelegateMus(user_window_controller_.get()));
   item_delegate->SetDelegate(std::move(delegate));
   item_delegate->set_pinned(true);
   item_delegate->set_title(item->app_title.To<base::string16>());
   Shell::GetInstance()->shelf_item_delegate_manager()->SetShelfItemDelegate(
       shelf_id, std::move(item_delegate));
 }
 
 void ShelfDelegateMus::UnpinItem(const mojo::String& app_id) {
   if (!app_id_to_shelf_id_.count(app_id.To<std::string>()))
     return;
   ShelfID shelf_id = app_id_to_shelf_id_[app_id.To<std::string>()];
   ShelfItemDelegateMus* item_delegate = GetShelfItemDelegate(shelf_id);
   DCHECK(item_delegate->pinned());
   item_delegate->set_pinned(false);
   if (item_delegate->window_id_to_title().empty()) {
     model_->RemoveItemAt(model_->ItemIndexByID(shelf_id));
     app_id_to_shelf_id_.erase(app_id.To<std::string>());
     shelf_id_to_app_id_.erase(shelf_id);
   }
 }
 
 void ShelfDelegateMus::SetItemImage(const mojo::String& app_id,
-                                    skia::mojom::BitmapPtr image) {
+                                    const SkBitmap& image) {
   if (!app_id_to_shelf_id_.count(app_id.To<std::string>()))
     return;
   ShelfID shelf_id = app_id_to_shelf_id_[app_id.To<std::string>()];
   int index = model_->ItemIndexByID(shelf_id);
   DCHECK_GE(index, 0);
   ShelfItem item = *model_->ItemByID(shelf_id);
-  item.image = GetShelfIconFromBitmap(image.To<SkBitmap>());
+  item.image = GetShelfIconFromBitmap(image);
   model_->Set(index, item);
 }
 
 void ShelfDelegateMus::OnUserWindowObserverAdded(
     mojo::Array<mash::wm::mojom::UserWindowPtr> user_windows) {
   for (size_t i = 0; i < user_windows.size(); ++i)
     OnUserWindowAdded(std::move(user_windows[i]));
 }
 
 void ShelfDelegateMus::OnUserWindowAdded(
@@ skipping 111 matching lines @@
   StatusAreaWidget* status_widget = widget->status_area_widget();
   mus::Window* status_window =
       aura::GetMusWindow(status_widget->GetNativeWindow());
   gfx::Size status_size = status_widget->GetWindowBoundsInScreen().size();
   status_window->SetSharedProperty<gfx::Size>(
       mus::mojom::WindowManager::kPreferredSize_Property, status_size);
 }
 
 }  // namespace sysui
 }  // namespace ash