Remove SW rendering path code from BrowserPlugin.

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/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/browser_plugin/browser_plugin_embedder.h"
 #include "content/browser/browser_plugin/browser_plugin_guest_manager.h"
 #include "content/browser/browser_plugin/browser_plugin_host_factory.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/frame_host/render_widget_host_view_guest.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view_guest.h"
 #include "content/common/browser_plugin/browser_plugin_constants.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/drag_messages.h"
-#include "content/common/gpu/gpu_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_view_host_delegate_view.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/navigation_controller.h"
-#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
-#include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/drop_data.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "net/url_request/url_request.h"
 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
 #include "ui/events/keycodes/keyboard_codes.h"
-#include "ui/surface/transport_dib.h"
 #include "webkit/common/resource_type.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/browser_plugin/browser_plugin_popup_menu_helper_mac.h"
 #endif
 
 namespace content {
 
 // static
 BrowserPluginHostFactory* BrowserPluginGuest::factory_ = NULL;
@@ skipping 130 matching lines @@
 };
 
 BrowserPluginGuest::BrowserPluginGuest(
     int instance_id,
     bool has_render_view,
     WebContentsImpl* web_contents,
     BrowserPluginGuest* opener)
     : WebContentsObserver(web_contents),
       embedder_web_contents_(NULL),
       instance_id_(instance_id),
-      damage_buffer_sequence_id_(0),
-      damage_buffer_size_(0),
-      damage_buffer_scale_factor_(1.0f),
       guest_device_scale_factor_(1.0f),
       guest_hang_timeout_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       focused_(false),
       mouse_locked_(false),
       pending_lock_request_(false),
       embedder_visible_(true),
       auto_size_enabled_(false),
       copy_request_id_(0),
       next_permission_request_id_(browser_plugin::kInvalidPermissionRequestID),
@@ skipping 180 matching lines @@
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetAutoSize, OnSetSize)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetEditCommandsForNextKeyEvent,
                         OnSetEditCommandsForNextKeyEvent)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetName, OnSetName)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetContentsOpaque,
                         OnSetContentsOpaque)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_SetVisibility, OnSetVisibility)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UnlockMouse_ACK, OnUnlockMouseAck)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateGeometry, OnUpdateGeometry)
-    IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_UpdateRect_ACK, OnUpdateRectACK)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void BrowserPluginGuest::Initialize(
     const BrowserPluginHostMsg_Attach_Params& params,
     WebContentsImpl* embedder_web_contents) {
   focused_ = params.focused;
   guest_visible_ = params.visible;
@@ skipping 354 matching lines @@
 bool BrowserPluginGuest::ShouldFocusPageAfterCrash() {
   // Rather than managing focus in WebContentsImpl::RenderViewReady, we will
   // manage the focus ourselves.
   return false;
 }
 
 WebContentsImpl* BrowserPluginGuest::GetWebContents() {
   return static_cast<WebContentsImpl*>(web_contents());
 }
 
-base::SharedMemory* BrowserPluginGuest::GetDamageBufferFromEmbedder(
-    const BrowserPluginHostMsg_ResizeGuest_Params& params) {
-  if (!attached()) {
-    LOG(WARNING) << "Attempting to map a damage buffer prior to attachment.";
-    return NULL;
-  }
-#if defined(OS_WIN)
-  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)) {
-    LOG(WARNING) << "Unable to map the embedder's damage buffer.";
-    return NULL;
-  }
-  return shared_buf.release();
-}
-
-void BrowserPluginGuest::SetDamageBuffer(
-    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(!damage_buffer_ ||
-      *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_rect.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;
 }
 
 bool BrowserPluginGuest::InAutoSizeBounds(const gfx::Size& size) const {
   return size.width() <= max_auto_size_.width() &&
       size.height() <= max_auto_size_.height();
@@ skipping 110 matching lines @@
   RenderViewHost* rvh = GetWebContents()->GetRenderViewHost();
   // The guest RenderView should always live in a guest process.
   CHECK(rvh->GetProcess()->IsGuest());
   // TODO(fsamuel): Investigate whether it's possible to update state earlier
   // here (see http://crbug.com/158151).
   Send(new InputMsg_SetFocus(routing_id(), focused_));
   UpdateVisibility();
   if (auto_size_enabled_)
     rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
   else
-    rvh->DisableAutoResize(damage_view_size_);
+    rvh->DisableAutoResize(full_size_);
 
   Send(new ViewMsg_SetName(routing_id(), name_));
   OnSetContentsOpaque(instance_id_, guest_opaque_);
 
   RenderWidgetHostImpl::From(rvh)->
       set_hung_renderer_delay_ms(guest_hang_timeout_);
 }
 
 void BrowserPluginGuest::RenderProcessGone(base::TerminationStatus status) {
   SendMessageToEmbedder(new BrowserPluginMsg_GuestGone(instance_id()));
@@ skipping 35 matching lines @@
     case BrowserPluginHostMsg_ReclaimCompositorResources::ID:
     case BrowserPluginHostMsg_ResizeGuest::ID:
     case BrowserPluginHostMsg_SetAutoSize::ID:
     case BrowserPluginHostMsg_SetEditCommandsForNextKeyEvent::ID:
     case BrowserPluginHostMsg_SetFocus::ID:
     case BrowserPluginHostMsg_SetName::ID:
     case BrowserPluginHostMsg_SetContentsOpaque::ID:
     case BrowserPluginHostMsg_SetVisibility::ID:
     case BrowserPluginHostMsg_UnlockMouse_ACK::ID:
     case BrowserPluginHostMsg_UpdateGeometry::ID:
-    case BrowserPluginHostMsg_UpdateRect_ACK::ID:
       return true;
     default:
       return false;
   }
 }
 
 bool BrowserPluginGuest::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(BrowserPluginGuest, message)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
@@ skipping 302 matching lines @@
       render_widget_host->NotifyScreenInfoChanged();
     }
   }
   // When autosize is turned off and as a result there is a layout change, we
   // send a sizechanged event.
   if (!auto_size_enabled_ && last_seen_auto_size_enabled_ &&
       !params.view_rect.size().IsEmpty() && delegate_) {
     delegate_->SizeChanged(last_seen_view_size_, params.view_rect.size());
     last_seen_auto_size_enabled_ = false;
   }
-  // Invalid damage buffer means we are in HW compositing mode,
-  // so just resize the WebContents and repaint if needed.
-  if (base::SharedMemory::IsHandleValid(params.damage_buffer_handle))
-    SetDamageBuffer(params);
+  // Just resize the WebContents and repaint if needed.
+  full_size_ = params.view_rect.size();
   if (!params.view_rect.size().IsEmpty())
     GetWebContents()->GetView()->SizeContents(params.view_rect.size());
   if (params.repaint)
     Send(new ViewMsg_Repaint(routing_id(), params.view_rect.size()));
 }
 
 void BrowserPluginGuest::OnSetFocus(int instance_id, bool focused) {
   focused_ = focused;
   Send(new InputMsg_SetFocus(routing_id(), focused));
   if (!focused && mouse_locked_)
@@ skipping 26 matching lines @@
   max_auto_size_ = auto_size_params.max_size;
   min_auto_size_ = auto_size_params.min_size;
   if (auto_size_enabled_ && (!old_auto_size_enabled ||
                              (old_max_size != max_auto_size_) ||
                              (old_min_size != min_auto_size_))) {
     RecordAction(
         base::UserMetricsAction("BrowserPlugin.Guest.EnableAutoResize"));
     GetWebContents()->GetRenderViewHost()->EnableAutoResize(
         min_auto_size_, max_auto_size_);
     // TODO(fsamuel): If we're changing autosize parameters, then we force
-    // the guest to completely repaint itself, because BrowserPlugin has
-    // allocated a new damage buffer and expects a full frame of pixels.
-    // Ideally, we shouldn't need to do this because we shouldn't need to
-    // allocate a new damage buffer unless |max_auto_size_| has changed.
+    // the guest to completely repaint itself.
+    // Ideally, we shouldn't need to do this unless |max_auto_size_| has
+    // changed.
     // However, even in that case, layout may not change and so we may
     // not get a full frame worth of pixels.
     Send(new ViewMsg_Repaint(routing_id(), max_auto_size_));
   } else if (!auto_size_enabled_ && old_auto_size_enabled) {
     GetWebContents()->GetRenderViewHost()->DisableAutoResize(
         resize_guest_params.view_rect.size());
   }
   OnResizeGuest(instance_id_, resize_guest_params);
 }
 
@@ skipping 31 matching lines @@
 
 void BrowserPluginGuest::OnUnlockMouseAck(int instance_id) {
   // mouse_locked_ could be false here if the lock attempt was cancelled due
   // to window focus, or for various other reasons before the guest was informed
   // of the lock's success.
   if (mouse_locked_)
     Send(new ViewMsg_MouseLockLost(routing_id()));
   mouse_locked_ = false;
 }
 
-void BrowserPluginGuest::OnUpdateRectACK(
-    int instance_id,
-    const BrowserPluginHostMsg_AutoSize_Params& auto_size_params,
-    const BrowserPluginHostMsg_ResizeGuest_Params& resize_guest_params) {
-  OnSetSize(instance_id_, auto_size_params, resize_guest_params);
-}
-
 void BrowserPluginGuest::OnCopyFromCompositingSurfaceAck(
     int instance_id,
     int request_id,
     const SkBitmap& bitmap) {
   CHECK(copy_request_callbacks_.count(request_id));
   if (!copy_request_callbacks_.count(request_id))
     return;
   const CopyRequestCallback& callback = copy_request_callbacks_[request_id];
   callback.Run(!bitmap.empty() && !bitmap.isNull(), bitmap);
   copy_request_callbacks_.erase(request_id);
@@ skipping 78 matching lines @@
       event.type == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 void BrowserPluginGuest::OnUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
   BrowserPluginMsg_UpdateRect_Params relay_params;
   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);
-  relay_params.needs_ack = false;
 
   bool size_changed = last_seen_view_size_ != params.view_size;
   gfx::Size old_size = last_seen_view_size_;
   last_seen_view_size_ = params.view_size;
 
   if ((auto_size_enabled_ || last_seen_auto_size_enabled_) &&
       size_changed && delegate_) {
     delegate_->SizeChanged(old_size, last_seen_view_size_);
   }
   last_seen_auto_size_enabled_ = auto_size_enabled_;
 
-  relay_params.damage_buffer_sequence_id = 0;
   SendMessageToEmbedder(
       new BrowserPluginMsg_UpdateRect(instance_id(), relay_params));
 }
 
 void BrowserPluginGuest::OnTextInputTypeChanged(ui::TextInputType type,
                                                 ui::TextInputMode input_mode,
                                                 bool can_compose_inline) {
   // Save the state of text input so we can restore it on focus.
   last_text_input_type_ = type;
   last_input_mode_ = input_mode;
@@ skipping 25 matching lines @@
     const GURL& url) {
   if (!url.is_valid()) {
     callback.Run(false);
     return;
   }
 
   delegate_->CanDownload(request_method, url, callback);
 }
 
 }  // namespace content