Apply merge from @fsamuel.

content/browser/browser_plugin/browser_plugin_guest.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/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 31 matching lines @@
 // static
 BrowserPluginHostFactory* BrowserPluginGuest::factory_ = NULL;
 
 BrowserPluginGuest::BrowserPluginGuest(
     int instance_id,
     WebContentsImpl* web_contents,
     const BrowserPluginHostMsg_CreateGuest_Params& params)
     : WebContentsObserver(web_contents),
       embedder_web_contents_(NULL),
       instance_id_(instance_id),
-#if defined(OS_WIN)
+      damage_buffer_sequence_id_(0),
       damage_buffer_size_(0),
-      remote_damage_buffer_handle_(0),
-#endif
       damage_buffer_scale_factor_(1.0f),
       pending_update_counter_(0),
       guest_hang_timeout_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       focused_(params.focused),
       visible_(params.visible),
       auto_size_enabled_(params.auto_size_params.enable),
       max_auto_size_(params.auto_size_params.max_size),
       min_auto_size_(params.auto_size_params.min_size) {
   DCHECK(web_contents);
@@ skipping 201 matching lines @@
 
 void BrowserPluginGuest::Resize(
     RenderViewHost* embedder_rvh,
     const BrowserPluginHostMsg_ResizeGuest_Params& params) {
   // BrowserPlugin manages resize flow control itself and does not depend
   // on RenderWidgetHost's mechanisms for flow control, so we reset those flags
   // here.
   RenderWidgetHostImpl* render_widget_host =
       RenderWidgetHostImpl::From(web_contents()->GetRenderViewHost());
   render_widget_host->ResetSizeAndRepaintPendingFlags();
-  if (!TransportDIB::is_valid_id(params.damage_buffer_id)) {
-    // Invalid transport dib, so just resize the WebContents.
+  if (!base::SharedMemory::IsHandleValid(params.damage_buffer_handle)) {
+    // Invalid damage buffer, so just resize the WebContents.
     if (!params.view_size.IsEmpty())
       web_contents()->GetView()->SizeContents(params.view_size);
     return;
   }
-  TransportDIB* damage_buffer =
-      GetDamageBufferFromEmbedder(embedder_rvh, params);
-  SetDamageBuffer(damage_buffer,
-#if defined(OS_WIN)
-                  params.damage_buffer_size,
-                  params.damage_buffer_id.handle,
-#endif
-                  params.view_size,
-                  params.scale_factor);
+  SetDamageBuffer(params);
   web_contents()->GetView()->SizeContents(params.view_size);
 }
 
-TransportDIB* BrowserPluginGuest::GetDamageBufferFromEmbedder(
-    RenderViewHost* embedder_rvh,
+base::SharedMemory* BrowserPluginGuest::GetDamageBufferFromEmbedder(
     const BrowserPluginHostMsg_ResizeGuest_Params& params) {
-  TransportDIB* damage_buffer = NULL;
 #if defined(OS_WIN)
-  // On Windows we need to duplicate the handle from the remote process.
-  HANDLE section;
-  DuplicateHandle(embedder_rvh->GetProcess()->GetHandle(),
-                  params.damage_buffer_id.handle,
-                  GetCurrentProcess(),
-                  &section,
-                  STANDARD_RIGHTS_REQUIRED | FILE_MAP_READ | FILE_MAP_WRITE,
-                  FALSE,
-                  0);
-  damage_buffer = TransportDIB::Map(section);
-#elif defined(OS_MACOSX)
-  // On OSX, we need the handle to map the transport dib.
-  damage_buffer = TransportDIB::Map(params.damage_buffer_handle);
-#elif defined(OS_ANDROID)
-  damage_buffer = TransportDIB::Map(params.damage_buffer_id);
-#elif defined(OS_POSIX)
-  damage_buffer = TransportDIB::Map(params.damage_buffer_id.shmkey);
-#endif  // defined(OS_POSIX)
-  DCHECK(damage_buffer);
-  return damage_buffer;
+  base::ProcessHandle handle =
+      embedder_web_contents_->GetRenderProcessHost()->GetHandle();
+  scoped_ptr<base::SharedMemory> shared_buf(
+      new base::SharedMemory(params.damage_buffer_handle, false, handle));
+ #elif defined(OS_POSIX)
+  scoped_ptr<base::SharedMemory> shared_buf(
+      new base::SharedMemory(params.damage_buffer_handle, false));
+#endif
+  if (!shared_buf->Map(params.damage_buffer_size)) {
+    NOTREACHED();
+    return NULL;
+  }
+  return shared_buf.release();
 }
 
 void BrowserPluginGuest::SetDamageBuffer(
-    TransportDIB* damage_buffer,
-#if defined(OS_WIN)
-    int damage_buffer_size,
-    TransportDIB::Handle remote_handle,
-#endif
-    const gfx::Size& damage_view_size,
-    float scale_factor) {
+    const BrowserPluginHostMsg_ResizeGuest_Params& params) {
+  damage_buffer_.reset(GetDamageBufferFromEmbedder(params));
   // Sanity check: Verify that we've correctly shared the damage buffer memory
   // between the embedder and browser processes.
-  DCHECK(*static_cast<unsigned int*>(damage_buffer->memory()) == 0xdeadbeef);
-  damage_buffer_.reset(damage_buffer);
-#if defined(OS_WIN)
-  damage_buffer_size_ = damage_buffer_size;
-  remote_damage_buffer_handle_ = remote_handle;
-#endif
-  damage_view_size_ = damage_view_size;
-  damage_buffer_scale_factor_ = scale_factor;
+  DCHECK(*static_cast<unsigned int*>(damage_buffer_->memory()) == 0xdeadbeef);
+  damage_buffer_sequence_id_ = params.damage_buffer_sequence_id;
+  damage_buffer_size_ = params.damage_buffer_size;
+  damage_view_size_ = params.view_size;
+  damage_buffer_scale_factor_ = params.scale_factor;
 }
 
 gfx::Point BrowserPluginGuest::GetScreenCoordinates(
     const gfx::Point& relative_position) const {
   gfx::Point screen_pos(relative_position);
   screen_pos += guest_window_rect_.OffsetFromOrigin();
   return screen_pos;
 }
 
 int BrowserPluginGuest::embedder_routing_id() const {
@@ skipping 40 matching lines @@
   // buffer's scale factor.
   // The scaling change can happen due to asynchronous updates of the DPI on a
   // resolution change.
   if (((auto_size_enabled_ && InAutoSizeBounds(params.view_size)) ||
       (params.view_size.width() == damage_view_size().width() &&
        params.view_size.height() == damage_view_size().height())) &&
        params.scale_factor == damage_buffer_scale_factor()) {
     TransportDIB* dib = render_view_host->GetProcess()->
         GetTransportDIB(params.bitmap);
     if (dib) {
+      size_t guest_damage_buffer_size =
 #if defined(OS_WIN)
-      size_t guest_damage_buffer_size = params.bitmap_rect.width() *
-                                        params.bitmap_rect.height() * 4;
+          params.bitmap_rect.width() *
+          params.bitmap_rect.height() * 4;
+#else
+          dib->size();
+#endif
       size_t embedder_damage_buffer_size = damage_buffer_size_;
-#else
-      size_t guest_damage_buffer_size = dib->size();
-      size_t embedder_damage_buffer_size = damage_buffer_->size();
-#endif
       void* guest_memory = dib->memory();
       void* embedder_memory = damage_buffer_->memory();
       size_t size = std::min(guest_damage_buffer_size,
                              embedder_damage_buffer_size);
       memcpy(embedder_memory, guest_memory, size);
     }
   }
   BrowserPluginMsg_UpdateRect_Params relay_params;
-#if defined(OS_MACOSX)
-  relay_params.damage_buffer_identifier = damage_buffer_->id();
-#elif defined(OS_WIN)
-  // On Windows, the handle used locally differs from the handle received from
-  // the embedder process, since we duplicate the remote handle.
-  relay_params.damage_buffer_identifier = remote_damage_buffer_handle_;
-#else
-  relay_params.damage_buffer_identifier = damage_buffer_->handle();
-#endif
+  relay_params.damage_buffer_sequence_id = damage_buffer_sequence_id_;
   relay_params.bitmap_rect = params.bitmap_rect;
   relay_params.scroll_delta = params.scroll_delta;
   relay_params.scroll_rect = params.scroll_rect;
   relay_params.copy_rects = params.copy_rects;
   relay_params.view_size = params.view_size;
   relay_params.scale_factor = params.scale_factor;
   relay_params.is_resize_ack = ViewHostMsg_UpdateRect_Flags::is_resize_ack(
       params.flags);
 
   // We need to send the ACK to the same render_view_host that issued
@@ skipping 225 matching lines @@
     default:
       break;
   }
 }
 
 void BrowserPluginGuest::SendMessageToEmbedder(IPC::Message* msg) {
   embedder_web_contents_->Send(msg);
 }
 
 }  // namespace content