Bitmap transport

chrome/browser/renderer_host/render_widget_host_unittest.cc

 // Copyright (c) 2009 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 "base/basictypes.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "chrome/browser/renderer_host/test_render_view_host.h"
 #include "chrome/common/render_messages.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(OS_POSIX)
-#include "skia/ext/platform_canvas.h"
-#endif
-
 namespace {
 
 // RenderWidgetHostProcess -----------------------------------------------------
 
 class RenderWidgetHostProcess : public MockRenderProcessHost {
  public:
   explicit RenderWidgetHostProcess(Profile* profile)
       : MockRenderProcessHost(profile),
-#if defined(OS_WIN)
         current_paint_buf_(NULL),
-#endif
         paint_msg_should_reply_(false),
         paint_msg_reply_flags_(0) {
     // DANGER! This is a hack. The RenderWidgetHost checks the channel to see
     // if the process is still alive, but it doesn't actually dereference it.
     // An IPC::SyncChannel is nontrivial, so we just fake it here. If you end up
     // crashing by dereferencing 1, then you'll have to make a real channel.
     channel_.reset(reinterpret_cast<IPC::SyncChannel*>(0x1));
   }
   ~RenderWidgetHostProcess() {
     // We don't want to actually delete the channel, since it's not a real
     // pointer.
     channel_.release();
   }
 
   void set_paint_msg_should_reply(bool reply) {
     paint_msg_should_reply_ = reply;
   }
   void set_paint_msg_reply_flags(int flags) {
     paint_msg_reply_flags_ = flags;
   }
 
   // Fills the given paint parameters with resonable default values.
   void InitPaintRectParams(ViewHostMsg_PaintRect_Params* params);
 
  protected:
   virtual bool WaitForPaintMsg(int render_widget_id,
                                const base::TimeDelta& max_delay,
                                IPC::Message* msg);
 
-#if defined(OS_WIN)
-  scoped_ptr<base::SharedMemory> current_paint_buf_;
-#elif defined(OS_POSIX)
-  skia::PlatformCanvas canvas;
-#endif
+  TransportDIB* current_paint_buf_;
 
   // Set to true when WaitForPaintMsg should return a successful paint messaage
   // reply. False implies timeout.
   bool paint_msg_should_reply_;
 
   // Indicates the flags that should be sent with a the repaint request. This
   // only has an effect when paint_msg_should_reply_ is true.
   int paint_msg_reply_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostProcess);
 };
 
 void RenderWidgetHostProcess::InitPaintRectParams(
     ViewHostMsg_PaintRect_Params* params) {
   // Create the shared backing store.
   const int w = 100, h = 100;
+  const size_t pixel_size = w * h * 4;
 
-#if defined(OS_WIN)
-  int pixel_size = w * h * 4;
-
-  current_paint_buf_.reset(new base::SharedMemory());
-  ASSERT_TRUE(current_paint_buf_->Create(std::wstring(), false, true,
-                                         pixel_size));
-
-  params->bitmap = current_paint_buf_->handle();
-#elif defined(OS_POSIX)
-  ASSERT_TRUE(canvas.initialize(w, h, true));
-  params->bitmap = canvas.getDevice()->accessBitmap(false);
-#endif
-
+  current_paint_buf_ = TransportDIB::Create(pixel_size, 0);
+  params->bitmap = current_paint_buf_->id();
   params->bitmap_rect = gfx::Rect(0, 0, w, h);
   params->view_size = gfx::Size(w, h);
   params->flags = paint_msg_reply_flags_;
 }
 
 bool RenderWidgetHostProcess::WaitForPaintMsg(int render_widget_id,
                                               const base::TimeDelta& max_delay,
                                               IPC::Message* msg) {
   if (!paint_msg_should_reply_)
     return false;
@@ skipping 207 matching lines @@
   EXPECT_FALSE(host_->is_hidden_);
 
   // It should have sent out a restored message with a request to paint.
   const IPC::Message* restored = process_->sink().GetUniqueMessageMatching(
       ViewMsg_WasRestored::ID);
   ASSERT_TRUE(restored);
   bool needs_repaint;
   ViewMsg_WasRestored::Read(restored, &needs_repaint);
   EXPECT_TRUE(needs_repaint);
 }