First fix to minimize copying of image data.

app/resource_bundle_linux.cc

 // Copyright (c) 2006-2008 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 "app/resource_bundle.h"
 
 #include <gtk/gtk.h>
 
 #include "app/app_paths.h"
 #include "app/gfx/font.h"
 #include "app/gfx/gtk_util.h"
 #include "app/l10n_util.h"
 #include "base/base_paths.h"
 #include "base/data_pack.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace {
 
 // Convert the raw image data into a GdkPixbuf.  The GdkPixbuf that is returned
 // has a ref count of 1 so the caller must call g_object_unref to free the
 // memory.
-GdkPixbuf* LoadPixbuf(std::vector<unsigned char>& data, bool rtl_enabled) {
+GdkPixbuf* LoadPixbuf(RefCountedStaticMemory* data, bool rtl_enabled) {
   ScopedGObject<GdkPixbufLoader>::Type loader(gdk_pixbuf_loader_new());
   bool ok = gdk_pixbuf_loader_write(loader.get(),
-      static_cast<guint8*>(data.data()), data.size(), NULL);
+      reinterpret_cast<const guint8*>(data->front()), data->size(), NULL);
   if (!ok)
     return NULL;
   // Calling gdk_pixbuf_loader_close forces the data to be parsed by the
   // loader.  We must do this before calling gdk_pixbuf_loader_get_pixbuf.
   ok = gdk_pixbuf_loader_close(loader.get(), NULL);
   if (!ok)
     return NULL;
   GdkPixbuf* pixbuf = gdk_pixbuf_loader_get_pixbuf(loader.get());
   if (!pixbuf)
     return NULL;
@@ skipping 68 matching lines @@
 
 void ResourceBundle::LoadThemeResources() {
   FilePath theme_data_path;
   PathService::Get(app::DIR_THEMES, &theme_data_path);
   theme_data_path = theme_data_path.Append(FILE_PATH_LITERAL("default.pak"));
   theme_data_ = new base::DataPack;
   bool success = theme_data_->Load(theme_data_path);
   DCHECK(success) << "failed to load theme data";
 }
 
-/* static */
-bool ResourceBundle::LoadResourceBytes(DataHandle module, int resource_id,
-                                       std::vector<unsigned char>* bytes) {
+// static
+RefCountedStaticMemory* ResourceBundle::LoadResourceBytes(
+    DataHandle module, int resource_id) {
   DCHECK(module);
-  base::StringPiece data;
-  if (!module->Get(resource_id, &data))
-    return false;
+  base::StringPiece bytes;
+  if (!module->Get(resource_id, &bytes))
+    return NULL;
 
-  bytes->resize(data.length());
-  memcpy(&(bytes->front()), data.data(), data.length());
-
-  return true;
+  return new RefCountedStaticMemory(
+      reinterpret_cast<const unsigned char*>(bytes.data()), bytes.length());
 }
 
 base::StringPiece ResourceBundle::GetRawDataResource(int resource_id) {
   DCHECK(resources_data_);
   base::StringPiece data;
   if (!resources_data_->Get(resource_id, &data))
     return base::StringPiece();
   return data;
 }
 
@@ skipping 27 matching lines @@
   int key = rtl_enabled ? -resource_id : resource_id;
 
   // Check to see if we already have the pixbuf in the cache.
   {
     AutoLock lock_scope(lock_);
     GdkPixbufMap::const_iterator found = gdk_pixbufs_.find(key);
     if (found != gdk_pixbufs_.end())
       return found->second;
   }
 
-  std::vector<unsigned char> data;
-  LoadImageResourceBytes(resource_id, &data);
-  GdkPixbuf* pixbuf = LoadPixbuf(data, rtl_enabled);
+  scoped_refptr<RefCountedStaticMemory> data(
+      LoadImageResourceBytes(resource_id));
+  GdkPixbuf* pixbuf = LoadPixbuf(data.get(), rtl_enabled);
 
   // We loaded successfully.  Cache the pixbuf.
   if (pixbuf) {
     AutoLock lock_scope(lock_);
 
     // Another thread raced us, and has already cached the pixbuf.
     if (gdk_pixbufs_.count(key)) {
       g_object_unref(pixbuf);
       return gdk_pixbufs_[key];
     }
@@ skipping 23 matching lines @@
   }
 }
 
 GdkPixbuf* ResourceBundle::GetPixbufNamed(int resource_id) {
   return GetPixbufImpl(resource_id, false);
 }
 
 GdkPixbuf* ResourceBundle::GetRTLEnabledPixbufNamed(int resource_id) {
   return GetPixbufImpl(resource_id, true);
 }