POSIX: bitmap data on the wire

chrome/browser/renderer_host/render_widget_host.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 "chrome/browser/renderer_host/render_widget_host.h"
 
-#include "base/gfx/gdi_util.h"
+#include "base/gfx/native_widget_types.h"
 #include "base/message_loop.h"
-#include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_widget_helper.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/common/notification_service.h"
-#include "chrome/common/win_util.h"
 #include "chrome/views/view.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webinputevent.h"
 
+#if defined(OS_WIN)
+#include "base/gfx/gdi_util.h"
+#include "chrome/app/chrome_dll_resource.h"
+#include "chrome/common/win_util.h"
+#endif  // defined(OS_WIN)
+
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 // How long to (synchronously) wait for the renderer to respond with a
 // PaintRect message, when our backing-store is invalid, before giving up and
 // returning a null or incorrectly sized backing-store from GetBackingStore.
 // This timeout impacts the "choppiness" of our window resize perf.
 static const int kPaintMsgTimeoutMS = 40;
 
 // How long to wait before we consider a renderer hung.
 static const int kHungRendererDelayMs = 20000;
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHost
 
 RenderWidgetHost::RenderWidgetHost(RenderProcessHost* process,
                                    int routing_id)
-    : process_(process),
+    : view_(NULL),
+      process_(process),
       routing_id_(routing_id),
-      resize_ack_pending_(false),
-      mouse_move_pending_(false),
-      view_(NULL),
       is_loading_(false),
       is_hidden_(false),
+      repaint_ack_pending_(false),
+      resize_ack_pending_(false),
       suppress_view_updating_(false),
+      mouse_move_pending_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
-      view_being_painted_(false),
-      repaint_ack_pending_(false) {
+      view_being_painted_(false) {
   if (routing_id_ == MSG_ROUTING_NONE)
     routing_id_ = process_->GetNextRoutingID();
 
   process_->Attach(this, routing_id_);
   // Because the widget initializes as is_hidden_ == false,
   // tell the process host that we're alive.
   process_->WidgetRestored();
 }
 
 RenderWidgetHost::~RenderWidgetHost() {
@@ skipping 210 matching lines @@
 
   ForwardInputEvent(mouse_event, sizeof(WebMouseEvent));
 }
 
 void RenderWidgetHost::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent));
 }
 
 void RenderWidgetHost::ForwardKeyboardEvent(const WebKeyboardEvent& key_event) {
+#if defined(OS_WIN)
   if (key_event.type == WebKeyboardEvent::CHAR &&
       (key_event.key_code == VK_RETURN || key_event.key_code == VK_SPACE))
     OnEnterOrSpace();
+#else
+  // TODO(port): we don't have portable keyboard codes yet
+  // Maybe use keyboard_codes.h if we stick with it
+  NOTIMPLEMENTED();
+#endif
 
   ForwardInputEvent(key_event, sizeof(WebKeyboardEvent));
 }
 
 void RenderWidgetHost::ForwardInputEvent(const WebInputEvent& input_event,
                                          int event_size) {
   if (!process_->channel())
     return;
 
   IPC::Message* message = new ViewMsg_HandleInputEvent(routing_id_);
@@ skipping 108 matching lines @@
   }
 
   bool is_repaint_ack =
       ViewHostMsg_PaintRect_Flags::is_repaint_ack(params.flags);
   if (is_repaint_ack) {
     repaint_ack_pending_ = false;
     TimeDelta delta = TimeTicks::Now() - repaint_start_time_;
     UMA_HISTOGRAM_TIMES(L"MPArch.RWH_RepaintDelta", delta);
   }
 
-  DCHECK(params.bitmap);
   DCHECK(!params.bitmap_rect.IsEmpty());
   DCHECK(!params.view_size.IsEmpty());
 
   // Paint the backing store. This will update it with the renderer-supplied
   // bits. The view will read out of the backing store later to actually draw
   // to the screen.
   PaintBackingStoreRect(params.bitmap, params.bitmap_rect, params.view_size);
 
   // ACK early so we can prefetch the next PaintRect if there is a next one.
   // This must be done AFTER we're done painting with the bitmap supplied by the
@@ skipping 118 matching lines @@
   view_->UpdateCursor(cursor);
 }
 
 void RenderWidgetHost::OnMsgImeUpdateStatus(ViewHostMsg_ImeControl control,
                                             const gfx::Rect& caret_rect) {
   if (view_) {
     view_->IMEUpdateStatus(control, caret_rect);
   }
 }
 
-void RenderWidgetHost::PaintBackingStoreRect(HANDLE bitmap,
+void RenderWidgetHost::PaintBackingStoreRect(BitmapWireData bitmap,
                                              const gfx::Rect& bitmap_rect,
                                              const gfx::Size& view_size) {
   if (is_hidden_) {
     // Don't bother updating the backing store when we're hidden. Just mark it
     // as being totally invalid. This will cause a complete repaint when the
     // view is restored.
     needs_repainting_on_restore_ = true;
     return;
   }
 
   // We use the view size according to the render view, which may not be
   // quite the same as the size of our window.
   gfx::Rect view_rect(0, 0, view_size.width(), view_size.height());
 
   bool needs_full_paint = false;
   BackingStore* backing_store =
       BackingStoreManager::PrepareBackingStore(this, view_rect,
                                                process_->process().handle(),
                                                bitmap, bitmap_rect,
                                                &needs_full_paint);
   DCHECK(backing_store != NULL);
   if (needs_full_paint) {
     repaint_start_time_ = TimeTicks::Now();
     repaint_ack_pending_ = true;
     Send(new ViewMsg_Repaint(routing_id_, view_size));
   }
 }
 
-void RenderWidgetHost::ScrollBackingStoreRect(HANDLE bitmap,
+void RenderWidgetHost::ScrollBackingStoreRect(BitmapWireData bitmap,
                                               const gfx::Rect& bitmap_rect,
                                               int dx, int dy,
                                               const gfx::Rect& clip_rect,
                                               const gfx::Size& view_size) {
   if (is_hidden_) {
     // Don't bother updating the backing store when we're hidden. Just mark it
     // as being totally invalid. This will cause a complete repaint when the
     // view is restored.
     needs_repainting_on_restore_ = true;
     return;
   }
 
   // TODO(darin): do we need to do something else if our backing store is not
   // the same size as the advertised view?  maybe we just assume there is a
   // full paint on its way?
   BackingStore* backing_store = BackingStoreManager::Lookup(this);
   if (!backing_store || (backing_store->size() != view_size))
     return;
   backing_store->ScrollRect(process_->process().handle(), bitmap, bitmap_rect,
                             dx, dy, clip_rect, view_size);
 }