Convert most of the rest of chrome to ImageSkia

chrome/browser/task_manager/task_manager_resource_providers.cc

 // Copyright (c) 2012 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/task_manager/task_manager_resource_providers.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_version_info.h"
 #include "base/i18n/rtl.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/process_util.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/background/background_contents_service_factory.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 28 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/process_type.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/image/image_skia.h"
 #include "v8/include/v8.h"
 
 #if defined(OS_MACOSX)
 #include "skia/ext/skia_utils_mac.h"
 #endif
 #if defined(OS_WIN)
 #include "chrome/browser/app_icon_win.h"
 #include "ui/gfx/icon_util.h"
 #endif  // defined(OS_WIN)
 
@@ skipping 144 matching lines @@
 
 bool TaskManagerRendererResource::SupportNetworkUsage() const {
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerTabContentsResource class
 ////////////////////////////////////////////////////////////////////////////////
 
 // static
-SkBitmap* TaskManagerTabContentsResource::prerender_icon_ = NULL;
+gfx::ImageSkia* TaskManagerTabContentsResource::prerender_icon_ = NULL;
 
 TaskManagerTabContentsResource::TaskManagerTabContentsResource(
     TabContentsWrapper* tab_contents)
     : TaskManagerRendererResource(
           tab_contents->web_contents()->GetRenderProcessHost()->GetHandle(),
           tab_contents->web_contents()->GetRenderViewHost()),
       tab_contents_(tab_contents),
       is_instant_preview_(false) {
   if (!prerender_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    prerender_icon_ = rb.GetBitmapNamed(IDR_PRERENDER);
+    prerender_icon_ = rb.GetImageSkiaNamed(IDR_PRERENDER);
   }
   for (BrowserList::const_iterator i = BrowserList::begin();
        i != BrowserList::end(); ++i) {
     if ((*i)->instant() &&
         (*i)->instant()->GetPreviewContents() == tab_contents_) {
       is_instant_preview_ = true;
       break;
     }
   }
 }
@@ skipping 68 matching lines @@
   ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   Profile* profile = tab_contents_->profile()->GetOriginalProfile();
   size_t index = cache.GetIndexOfProfileWithPath(profile->GetPath());
   if (index == std::string::npos)
     return string16();
   else
     return cache.GetNameOfProfileAtIndex(index);
 }
 
-SkBitmap TaskManagerTabContentsResource::GetIcon() const {
+gfx::ImageSkia TaskManagerTabContentsResource::GetIcon() const {
   if (IsPrerendering())
     return *prerender_icon_;
   return tab_contents_->favicon_tab_helper()->GetFavicon();
 }
 
 TabContentsWrapper* TaskManagerTabContentsResource::GetTabContents() const {
   return tab_contents_;
 }
 
 const Extension* TaskManagerTabContentsResource::GetExtension() const {
@@ skipping 185 matching lines @@
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerBackgroundContentsResource class
 ////////////////////////////////////////////////////////////////////////////////
 
-SkBitmap* TaskManagerBackgroundContentsResource::default_icon_ = NULL;
+gfx::ImageSkia* TaskManagerBackgroundContentsResource::default_icon_ = NULL;
 
 // TODO(atwilson): http://crbug.com/116893
 // HACK: if the process handle is invalid, we use the current process's handle.
 // This preserves old behavior but is incorrect, and should be fixed.
 TaskManagerBackgroundContentsResource::TaskManagerBackgroundContentsResource(
     BackgroundContents* background_contents,
     const string16& application_name)
     : TaskManagerRendererResource(
           background_contents->web_contents()->GetRenderProcessHost()->
               GetHandle() ?
               background_contents->web_contents()->GetRenderProcessHost()->
                   GetHandle() :
               base::Process::Current().handle(),
           background_contents->web_contents()->GetRenderViewHost()),
       background_contents_(background_contents),
       application_name_(application_name) {
   // Just use the same icon that other extension resources do.
   // TODO(atwilson): Use the favicon when that's available.
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
+    default_icon_ = rb.GetImageSkiaNamed(IDR_PLUGIN);
   }
   // Ensure that the string has the appropriate direction markers (see comment
   // in TaskManagerTabContentsResource::GetTitle()).
   base::i18n::AdjustStringForLocaleDirection(&application_name_);
 }
 
 TaskManagerBackgroundContentsResource::~TaskManagerBackgroundContentsResource(
     ) {
 }
 
 string16 TaskManagerBackgroundContentsResource::GetTitle() const {
   string16 title = application_name_;
 
   if (title.empty()) {
     // No title (can't locate the parent app for some reason) so just display
     // the URL (properly forced to be LTR).
     title = base::i18n::GetDisplayStringInLTRDirectionality(
         UTF8ToUTF16(background_contents_->GetURL().spec()));
   }
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_BACKGROUND_PREFIX, title);
 }
 
 string16 TaskManagerBackgroundContentsResource::GetProfileName() const {
   return string16();
 }
 
-SkBitmap TaskManagerBackgroundContentsResource::GetIcon() const {
+gfx::ImageSkia TaskManagerBackgroundContentsResource::GetIcon() const {
   return *default_icon_;
 }
 
 bool TaskManagerBackgroundContentsResource::IsBackground() const {
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerBackgroundContentsResourceProvider class
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 188 matching lines @@
       break;
     default:
       NOTREACHED() << "Unexpected notification.";
       return;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerChildProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
-SkBitmap* TaskManagerChildProcessResource::default_icon_ = NULL;
+gfx::ImageSkia* TaskManagerChildProcessResource::default_icon_ = NULL;
 
 TaskManagerChildProcessResource::TaskManagerChildProcessResource(
     content::ProcessType type,
     const string16& name,
     base::ProcessHandle handle,
     int unique_process_id)
     : type_(type),
       name_(name),
       handle_(handle),
       unique_process_id_(unique_process_id),
       network_usage_support_(false) {
   // We cache the process id because it's not cheap to calculate, and it won't
   // be available when we get the plugin disconnected notification.
   pid_ = base::GetProcId(handle);
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
+    default_icon_ = rb.GetImageSkiaNamed(IDR_PLUGIN);
     // TODO(jabdelmalek): use different icon for web workers.
   }
 }
 
 TaskManagerChildProcessResource::~TaskManagerChildProcessResource() {
 }
 
 // TaskManagerResource methods:
 string16 TaskManagerChildProcessResource::GetTitle() const {
   if (title_.empty())
     title_ = GetLocalizedTitle();
 
   return title_;
 }
 
 string16 TaskManagerChildProcessResource::GetProfileName() const {
   return string16();
 }
 
-SkBitmap TaskManagerChildProcessResource::GetIcon() const {
+gfx::ImageSkia TaskManagerChildProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 base::ProcessHandle TaskManagerChildProcessResource::GetProcess() const {
   return handle_;
 }
 
 int TaskManagerChildProcessResource::GetUniqueChildProcessId() const {
   return unique_process_id_;
 }
@@ skipping 265 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TASK_MANAGER_CHILD_PROCESSES_DATA_READY,
       content::Source<TaskManagerChildProcessResourceProvider>(this),
       content::NotificationService::NoDetails());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerExtensionProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 
-SkBitmap* TaskManagerExtensionProcessResource::default_icon_ = NULL;
+gfx::ImageSkia* TaskManagerExtensionProcessResource::default_icon_ = NULL;
 
 TaskManagerExtensionProcessResource::TaskManagerExtensionProcessResource(
     content::RenderViewHost* render_view_host)
     : render_view_host_(render_view_host) {
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    default_icon_ = rb.GetBitmapNamed(IDR_PLUGIN);
+    default_icon_ = rb.GetImageSkiaNamed(IDR_PLUGIN);
   }
   process_handle_ = render_view_host_->GetProcess()->GetHandle();
   unique_process_id_ = render_view_host->GetProcess()->GetID();
   pid_ = base::GetProcId(process_handle_);
   string16 extension_name = UTF8ToUTF16(GetExtension()->name());
   DCHECK(!extension_name.empty());
 
   Profile* profile = Profile::FromBrowserContext(
       render_view_host->GetProcess()->GetBrowserContext());
   int message_id = GetMessagePrefixID(GetExtension()->is_app(), true,
@@ skipping 14 matching lines @@
   Profile* profile = Profile::FromBrowserContext(
       render_view_host_->GetProcess()->GetBrowserContext());
   profile = profile->GetOriginalProfile();
   size_t index = cache.GetIndexOfProfileWithPath(profile->GetPath());
   if (index == std::string::npos)
     return string16();
   else
     return cache.GetNameOfProfileAtIndex(index);
 }
 
-SkBitmap TaskManagerExtensionProcessResource::GetIcon() const {
+gfx::ImageSkia TaskManagerExtensionProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 base::ProcessHandle TaskManagerExtensionProcessResource::GetProcess() const {
   return process_handle_;
 }
 
 int TaskManagerExtensionProcessResource::GetUniqueChildProcessId() const {
   return unique_process_id_;
 }
@@ skipping 195 matching lines @@
     pid_to_resources_.erase(pid_iter);
 
   // Finally, delete the resource.
   delete resource;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerBrowserProcessResource class
 ////////////////////////////////////////////////////////////////////////////////
 
-SkBitmap* TaskManagerBrowserProcessResource::default_icon_ = NULL;
+gfx::ImageSkia* TaskManagerBrowserProcessResource::default_icon_ = NULL;
 
 TaskManagerBrowserProcessResource::TaskManagerBrowserProcessResource()
     : title_() {
   int pid = base::GetCurrentProcId();
   bool success = base::OpenPrivilegedProcessHandle(pid, &process_);
   DCHECK(success);
 #if defined(OS_WIN)
   if (!default_icon_) {
     HICON icon = GetAppIcon();
     if (icon) {
-      default_icon_ = IconUtil::CreateSkBitmapFromHICON(icon);
+      scoped_ptr<SkBitmap> bitmap(IconUtil::CreateSkBitmapFromHICON(icon));
+      default_icon_ = new gfx::ImageSkia(*bitmap);
     }
   }
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
   if (!default_icon_) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-    default_icon_ = rb.GetBitmapNamed(IDR_PRODUCT_LOGO_16);
+    default_icon_ = rb.GetImageSkiaNamed(IDR_PRODUCT_LOGO_16);
   }
 #elif defined(OS_MACOSX)
   if (!default_icon_) {
     // IDR_PRODUCT_LOGO_16 doesn't quite look like chrome/mac's icns icon. Load
     // the real app icon (requires a nsimage->skbitmap->nsimage conversion :-().
-    default_icon_ = new SkBitmap(gfx::AppplicationIconAtSize(16));
+    default_icon_ = new gfx::ImageSkia(gfx::AppplicationIconAtSize(16));
   }
 #else
   // TODO(port): Port icon code.
   NOTIMPLEMENTED();
 #endif  // defined(OS_WIN)
 }
 
 TaskManagerBrowserProcessResource::~TaskManagerBrowserProcessResource() {
   base::CloseProcessHandle(process_);
 }
 
 // TaskManagerResource methods:
 string16 TaskManagerBrowserProcessResource::GetTitle() const {
   if (title_.empty()) {
     title_ = l10n_util::GetStringUTF16(IDS_TASK_MANAGER_WEB_BROWSER_CELL_TEXT);
   }
   return title_;
 }
 
 string16 TaskManagerBrowserProcessResource::GetProfileName() const {
   return string16();
 }
 
-SkBitmap TaskManagerBrowserProcessResource::GetIcon() const {
+gfx::ImageSkia TaskManagerBrowserProcessResource::GetIcon() const {
   return *default_icon_;
 }
 
 size_t TaskManagerBrowserProcessResource::SqliteMemoryUsedBytes() const {
   return static_cast<size_t>(sqlite3_memory_used());
 }
 
 base::ProcessHandle TaskManagerBrowserProcessResource::GetProcess() const {
   return base::GetCurrentProcessHandle();  // process_;
 }
@@ skipping 64 matching lines @@
 
   return &resource_;
 }
 
 void TaskManagerBrowserProcessResourceProvider::StartUpdating() {
   task_manager_->AddResource(&resource_);
 }
 
 void TaskManagerBrowserProcessResourceProvider::StopUpdating() {
 }