Converts ui/views/controls, ui/views/examples, ui/base/models to ImageSkia

ui/views/controls/menu/menu.h

 // Copyright (c) 2011 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.
 
 #ifndef UI_VIEWS_CONTROLS_MENU_MENU_H_
 #define UI_VIEWS_CONTROLS_MENU_MENU_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/string16.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/views/views_export.h"
 
-class SkBitmap;
-
 namespace gfx {
+class ImageSkia;
 class Point;
 }
 
 namespace ui {
 class Accelerator;
 }
 
 namespace views {
 
 class VIEWS_EXPORT Menu {
@@ skipping 27 matching lines @@
     }
 
     // The delegate needs to implement this function if it wants to display
     // the shortcut text next to each menu item. If there is an accelerator
     // for a given item id, the implementor must return it.
     virtual bool GetAcceleratorInfo(int id, ui::Accelerator* accel) {
       return false;
     }
 
     // The icon shown for the menu item.
-    virtual const SkBitmap& GetIcon(int id) const {
+    virtual const gfx::ImageSkia& GetIcon(int id) const {
       return GetEmptyIcon();
     }
 
     // The number of items to show in the menu
     virtual int GetItemCount() const {
       return 0;
     }
 
     // Whether or not an item is a separator.
     virtual bool IsItemSeparator(int id) const {
@@ skipping 40 matching lines @@
       return true;
     }
     virtual bool GetContextualLabel(int id, string16* out) const {
       return false;
     }
     virtual void ExecuteCommand(int id) {
     }
 
    protected:
     // Returns an empty icon.
-    const SkBitmap& GetEmptyIcon() const;
+    const gfx::ImageSkia& GetEmptyIcon() const;
   };
 
   // How this popup should align itself relative to the point it is run at.
   enum AnchorPoint {
     TOPLEFT,
     TOPRIGHT
   };
 
   // Different types of menu items
   enum MenuItemType {
@@ skipping 49 matching lines @@
   Menu* AppendSubMenu(int item_id,
                       const string16& label);
   Menu* AddSubMenu(int index, int item_id, const string16& label);
 
   // Append a submenu with an icon to this menu
   // The returned pointer is owned by this menu.
   // Unless the icon is empty, calling this function forces the Menu class
   // to draw the menu, instead of relying on Windows.
   Menu* AppendSubMenuWithIcon(int item_id,
                               const string16& label,
-                              const SkBitmap& icon);
+                              const gfx::ImageSkia& icon);
   virtual Menu* AddSubMenuWithIcon(int index,
                                    int item_id,
                                    const string16& label,
-                                   const SkBitmap& icon) = 0;
+                                   const gfx::ImageSkia& icon) = 0;
 
   // This is a convenience for standard text label menu items where the label
   // is provided with this call.
   void AppendMenuItemWithLabel(int item_id, const string16& label);
   void AddMenuItemWithLabel(int index, int item_id, const string16& label);
 
   // This is a convenience for text label menu items where the label is
   // provided by the delegate.
   void AppendDelegateMenuItem(int item_id);
   void AddDelegateMenuItem(int index, int item_id);
 
   // Adds a separator to this menu
   void AppendSeparator();
   virtual void AddSeparator(int index) = 0;
 
   // Appends a menu item with an icon. This is for the menu item which
   // needs an icon. Calling this function forces the Menu class to draw
   // the menu, instead of relying on Windows.
   void AppendMenuItemWithIcon(int item_id,
                               const string16& label,
-                              const SkBitmap& icon);
+                              const gfx::ImageSkia& icon);
   virtual void AddMenuItemWithIcon(int index,
                                    int item_id,
                                    const string16& label,
-                                   const SkBitmap& icon);
+                                   const gfx::ImageSkia& icon);
 
   // Enables or disables the item with the specified id.
   virtual void EnableMenuItemByID(int item_id, bool enabled) = 0;
   virtual void EnableMenuItemAt(int index, bool enabled) = 0;
 
   // Sets menu label at specified index.
   virtual void SetMenuLabel(int item_id, const string16& label) = 0;
 
   // Sets an icon for an item with a given item_id. Calling this function
   // also forces the Menu class to draw the menu, instead of relying on Windows.
   // Returns false if the item with |item_id| is not found.
-  virtual bool SetIcon(const SkBitmap& icon, int item_id) = 0;
+  virtual bool SetIcon(const gfx::ImageSkia& icon, int item_id) = 0;
 
   // Shows the menu, blocks until the user dismisses the menu or selects an
   // item, and executes the command for the selected item (if any).
   // Warning: Blocking call. Will implicitly run a message loop.
   virtual void RunMenuAt(int x, int y) = 0;
 
   // Cancels the menu.
   virtual void Cancel() = 0;
 
   // Returns the number of menu items.
   virtual int ItemCount() = 0;
 
 #if defined(OS_WIN)
   // Returns the underlying menu handle
   virtual HMENU GetMenuHandle() const = 0;
 #endif  // defined(OS_WIN)
 
  protected:
   explicit Menu(Menu* parent);
 
   virtual void AddMenuItemInternal(int index,
                                    int item_id,
                                    const string16& label,
-                                   const SkBitmap& icon,
+                                   const gfx::ImageSkia& icon,
                                    MenuItemType type) = 0;
 
  private:
   // The delegate that is being used to get information about the presentation.
   Delegate* delegate_;
 
   // How this popup menu should be aligned relative to the point it is run at.
   AnchorPoint anchor_;
 
   DISALLOW_COPY_AND_ASSIGN(Menu);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_MENU_MENU_H_