Allow PPB_ImageData_Impl to be created in a way that is compatible with unittests

content/renderer/pepper/ppb_image_data_impl.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 "content/renderer/pepper/ppb_image_data_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/pepper/common.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/c/ppb_image_data.h"
 #include "ppapi/thunk/thunk.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "ui/surface/transport_dib.h"
 
 using ppapi::thunk::PPB_ImageData_API;
 
 namespace content {
 
 PPB_ImageData_Impl::PPB_ImageData_Impl(PP_Instance instance,
-                                       PPB_ImageData_Shared::ImageDataType type)
+                                       PPB_ImageData_Shared::ImageDataType type,
+                                       bool is_browser_allocated)

[bbudge, 2013/11/11 12:24:06]

Couldn't we just call IsBrowserAllocated on the type here?

[bbudge, 2013/11/11 19:09:15]

Never mind, I realized this is the whole point of this CL.

     : Resource(ppapi::OBJECT_IS_IMPL, instance),
       format_(PP_IMAGEDATAFORMAT_BGRA_PREMUL),
       width_(0),
       height_(0) {
   switch (type) {
     case PPB_ImageData_Shared::PLATFORM:
-      backend_.reset(new ImageDataPlatformBackend);
+      backend_.reset(new ImageDataPlatformBackend(is_browser_allocated));
       return;
     case PPB_ImageData_Shared::SIMPLE:
+      DCHECK(!is_browser_allocated) <<
+          "PPB_ImageData_Shared::SIMPLE is always allocated in the renderer.";
       backend_.reset(new ImageDataSimpleBackend);
       return;
     // No default: so that we get a compiler warning if any types are added.
   }
   NOTREACHED();
 }
 
 PPB_ImageData_Impl::~PPB_ImageData_Impl() {
 }
 
+// static
+bool PPB_ImageData_Impl::IsBrowserAllocated(ImageDataType format) {
+  if (format == PPB_ImageData_Shared::SIMPLE)
+    return false;
+#if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
+  // On the Mac, shared memory has to be created in the browser in order to
+  // work in the sandbox.
+  return true;
+#endif
+  return false;
+}
+
 bool PPB_ImageData_Impl::Init(PP_ImageDataFormat format,
                               int width, int height,
                               bool init_to_zero) {
   // TODO(brettw) this should be called only on the main thread!
   if (!IsImageDataFormatSupported(format))
     return false;  // Only support this one format for now.
   if (width <= 0 || height <= 0)
     return false;
   if (static_cast<int64>(width) * static_cast<int64>(height) >=
       std::numeric_limits<int32>::max() / 4)
     return false;  // Prevent overflow of signed 32-bit ints.
 
   format_ = format;
   width_ = width;
   height_ = height;
   return backend_->Init(this, format, width, height, init_to_zero);
 }
 
 // static
 PP_Resource PPB_ImageData_Impl::Create(PP_Instance instance,
                                        PPB_ImageData_Shared::ImageDataType type,
                                        PP_ImageDataFormat format,
                                        const PP_Size& size,
                                        PP_Bool init_to_zero) {
   scoped_refptr<PPB_ImageData_Impl>
-      data(new PPB_ImageData_Impl(instance, type));
+      data(new PPB_ImageData_Impl(instance, type, IsBrowserAllocated(type)));
   if (!data->Init(format, size.width, size.height, !!init_to_zero))
     return 0;
   return data->GetReference();
 }
 
 PPB_ImageData_API* PPB_ImageData_Impl::AsPPB_ImageData_API() {
   return this;
 }
 
 bool PPB_ImageData_Impl::IsMapped() const {
@@ skipping 35 matching lines @@
 void PPB_ImageData_Impl::SetIsCandidateForReuse() {
   // Nothing to do since we don't support image data re-use in-process.
 }
 
 const SkBitmap* PPB_ImageData_Impl::GetMappedBitmap() const {
   return backend_->GetMappedBitmap();
 }
 
 // ImageDataPlatformBackend ----------------------------------------------------
 
-ImageDataPlatformBackend::ImageDataPlatformBackend()
+ImageDataPlatformBackend::ImageDataPlatformBackend(bool is_browser_allocated)
     : width_(0),
-      height_(0) {
+      height_(0),
+      is_browser_allocated_(is_browser_allocated) {
 }
 
 // On POSIX, we have to tell the browser to free the transport DIB.
 ImageDataPlatformBackend::~ImageDataPlatformBackend() {
-#if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
-  if (dib_) {
-    RenderThreadImpl::current()->Send(
-        new ViewHostMsg_FreeTransportDIB(dib_->id()));
+  if (is_browser_allocated_) {
+    if (dib_) {
+      RenderThreadImpl::current()->Send(
+          new ViewHostMsg_FreeTransportDIB(dib_->id()));
+    }
   }
-#endif
 }
 
 bool ImageDataPlatformBackend::Init(PPB_ImageData_Impl* impl,
                                     PP_ImageDataFormat format,
                                     int width, int height,
                                     bool init_to_zero) {
   // TODO(brettw) use init_to_zero when we implement caching.
   width_ = width;
   height_ = height;
   uint32 buffer_size = width_ * height_ * 4;
 
   // Allocate the transport DIB and the PlatformCanvas pointing to it.
-#if defined(OS_POSIX) && !defined(TOOLKIT_GTK) && !defined(OS_ANDROID)
-  // On the Mac, shared memory has to be created in the browser in order to
-  // work in the sandbox.  Do this by sending a message to the browser
-  // requesting a TransportDIB (see also
-  // chrome/renderer/webplugin_delegate_proxy.cc, method
-  // WebPluginDelegateProxy::CreateBitmap() for similar code). The TransportDIB
-  // is cached in the browser, and is freed (in typical cases) by the
-  // TransportDIB's destructor.
-  TransportDIB::Handle dib_handle;
-  IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(buffer_size,
-                                                        true,
-                                                        &dib_handle);
-  if (!RenderThreadImpl::current()->Send(msg))
-    return false;
-  if (!TransportDIB::is_valid_handle(dib_handle))
-    return false;
+  TransportDIB* dib = NULL;
+  if (is_browser_allocated_) {
+    // Allocate the image data by sending a message to the browser requesting a
+    // TransportDIB (see also chrome/renderer/webplugin_delegate_proxy.cc,
+    // method WebPluginDelegateProxy::CreateBitmap() for similar code). The
+    // TransportDIB is cached in the browser, and is freed (in typical cases) by
+    // the TransportDIB's destructor.
+    TransportDIB::Handle dib_handle;
+    IPC::Message* msg = new ViewHostMsg_AllocTransportDIB(buffer_size,
+                                                          true,
+                                                          &dib_handle);
+    if (!RenderThreadImpl::current()->Send(msg))
+      return false;
+    if (!TransportDIB::is_valid_handle(dib_handle))
+      return false;
 
-  TransportDIB* dib = TransportDIB::CreateWithHandle(dib_handle);
-#else
-  static int next_dib_id = 0;
-  TransportDIB* dib = TransportDIB::Create(buffer_size, next_dib_id++);
-  if (!dib)
-    return false;
-#endif
+    dib = TransportDIB::CreateWithHandle(dib_handle);
+  } else {
+    static int next_dib_id = 0;
+    dib = TransportDIB::Create(buffer_size, next_dib_id++);
+    if (!dib)
+      return false;
+  }
   dib_.reset(dib);
   return true;
 }
 
 bool ImageDataPlatformBackend::IsMapped() const {
   return !!mapped_canvas_.get();
 }
 
 TransportDIB* ImageDataPlatformBackend::GetTransportDIB() const {
   return dib_.get();
@@ skipping 119 matching lines @@
   return skia_canvas_.get();
 }
 
 const SkBitmap* ImageDataSimpleBackend::GetMappedBitmap() const {
   if (!IsMapped())
     return NULL;
   return &skia_bitmap_;
 }
 
 }  // namespace content