Remove SW rendering path code from BrowserPlugin.

content/browser/browser_plugin/browser_plugin_guest.h

 // 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.
 
 // A BrowserPluginGuest is the browser side of a browser <--> embedder
 // renderer channel. A BrowserPlugin (a WebPlugin) is on the embedder
 // renderer side of browser <--> embedder renderer communication.
 //
 // BrowserPluginGuest lives on the UI thread of the browser process. Any
 // messages about the guest render process that the embedder might be interested
 // in receiving should be listened for here.
 //
 // BrowserPluginGuest is a WebContentsDelegate and WebContentsObserver for the
 // guest WebContents. BrowserPluginGuest operates under the assumption that the
 // guest will be accessible through only one RenderViewHost for the lifetime of
 // the guest WebContents. Thus, cross-process navigation is not supported.
 
 #ifndef CONTENT_BROWSER_BROWSER_PLUGIN_BROWSER_PLUGIN_GUEST_H_
 #define CONTENT_BROWSER_BROWSER_PLUGIN_BROWSER_PLUGIN_GUEST_H_
 
 #include <map>
 #include <queue>
 
 #include "base/compiler_specific.h"
-#include "base/id_map.h"
-#include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "content/common/edit_command.h"
 #include "content/port/common/input_event_ack_state.h"
 #include "content/public/browser/browser_plugin_guest_delegate.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/browser_plugin_permission_type.h"
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "third_party/WebKit/public/web/WebDragOperation.h"
 #include "third_party/WebKit/public/web/WebDragStatus.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/base/ime/text_input_mode.h"
 #include "ui/base/ime/text_input_type.h"
 #include "ui/gfx/rect.h"
 #include "ui/surface/transport_dib.h"
 
 struct BrowserPluginHostMsg_AutoSize_Params;
 struct BrowserPluginHostMsg_Attach_Params;
 struct BrowserPluginHostMsg_ResizeGuest_Params;
-struct FrameHostMsg_BuffersSwappedACK_Params;
 struct FrameHostMsg_CompositorFrameSwappedACK_Params;
 struct FrameHostMsg_ReclaimCompositorResources_Params;
-struct ViewHostMsg_CreateWindow_Params;
 #if defined(OS_MACOSX)
 struct ViewHostMsg_ShowPopup_Params;
 #endif
 struct ViewHostMsg_UpdateRect_Params;
 
-namespace cc {
-class CompositorFrameAck;
-}
-
 namespace blink {
 class WebInputEvent;
 }
 
 namespace gfx {
 class Range;
 }
 
-namespace gpu {
-struct Mailbox;
-}
-
 namespace content {
 
 class BrowserPluginHostFactory;
-class BrowserPluginEmbedder;
-class BrowserPluginGuestManager;
-class RenderProcessHost;
 class RenderWidgetHostView;
 class SiteInstance;
 class WebCursor;
 struct DropData;
 struct MediaStreamRequest;
 
 // A browser plugin guest provides functionality for WebContents to operate in
 // the guest role and implements guest-specific overrides for ViewHostMsg_*
 // messages.
 //
@@ skipping 54 matching lines @@
   WebContentsImpl* embedder_web_contents() const {
     return embedder_web_contents_;
   }
 
   // Returns the embedder's RenderWidgetHostView if it is available.
   // Returns NULL otherwise.
   RenderWidgetHostView* GetEmbedderRenderWidgetHostView();
 
   bool focused() const { return focused_; }
   bool visible() const { return guest_visible_; }
-  void clear_damage_buffer() { damage_buffer_.reset(); }
   bool is_in_destruction() { return is_in_destruction_; }
 
   BrowserPluginGuest* opener() const { return opener_.get(); }
 
   // Returns whether the mouse pointer was unlocked.
   bool UnlockMouseIfNecessary(const NativeWebKeyboardEvent& event);
 
   void UpdateVisibility();
 
   void CopyFromCompositingSurface(
@@ skipping 68 matching lines @@
       WebContents* web_contents,
       const MediaStreamRequest& request,
       const MediaResponseCallback& callback) OVERRIDE;
   virtual bool PreHandleGestureEvent(
       content::WebContents* source,
       const blink::WebGestureEvent& event) OVERRIDE;
 
   // Exposes the protected web_contents() from WebContentsObserver.
   WebContentsImpl* GetWebContents();
 
-  // Overridden in tests.
-  virtual void SetDamageBuffer(
-      const BrowserPluginHostMsg_ResizeGuest_Params& params);
-
   gfx::Point GetScreenCoordinates(const gfx::Point& relative_position) const;
 
   // Helper to send messages to embedder. This methods fills the message with
   // the correct routing id.
   // Overridden in test implementation since we want to intercept certain
   // messages for testing.
   virtual void SendMessageToEmbedder(IPC::Message* msg);
 
   // Returns whether the guest is attached to an embedder.
   bool attached() const { return embedder_web_contents_ != NULL; }
@@ skipping 77 matching lines @@
   // Returns the |request_id| generated for the |request| provided.
   void RequestPermission(
       BrowserPluginPermissionType permission_type,
       scoped_refptr<BrowserPluginGuest::PermissionRequest> request,
       const base::DictionaryValue& request_info);
 
   // Creates a new guest window, and BrowserPluginGuest that is owned by this
   // BrowserPluginGuest.
   BrowserPluginGuest* CreateNewGuestWindow(const OpenURLParams& params);
 
-  base::SharedMemory* damage_buffer() const { return damage_buffer_.get(); }
-  const gfx::Size& damage_view_size() const { return damage_view_size_; }
-  float damage_buffer_scale_factor() const {
-    return damage_buffer_scale_factor_;
-  }
-  // Returns the damage buffer corresponding to the handle in resize |params|.
-  base::SharedMemory* GetDamageBufferFromEmbedder(
-      const BrowserPluginHostMsg_ResizeGuest_Params& params);
-
   bool InAutoSizeBounds(const gfx::Size& size) const;
 
   void RequestNewWindowPermission(WindowOpenDisposition disposition,
                                   const gfx::Rect& initial_bounds,
                                   bool user_gesture,
                                   WebContentsImpl* new_contents);
 
   // Message handlers for messages from embedder.
 
   void OnCompositorFrameSwappedACK(
@@ skipping 14 matching lines @@
                           const gfx::Point& location);
   // Instructs the guest to execute an edit command decoded in the embedder.
   void OnExecuteEditCommand(int instance_id,
                             const std::string& command);
 
   // Returns compositor resources reclaimed in the embedder to the guest.
   void OnReclaimCompositorResources(
       int instance_id,
       const FrameHostMsg_ReclaimCompositorResources_Params& params);
 
-  // Overriden in tests.
+  // Overridden in tests.
   virtual void OnHandleInputEvent(int instance_id,
                                   const gfx::Rect& guest_window_rect,
                                   const blink::WebInputEvent* event);
   void OnLockMouse(bool user_gesture,
                    bool last_unlocked_by_target,
                    bool privileged);
   void OnLockMouseAck(int instance_id, bool succeeded);
   void OnNavigateGuest(int instance_id, const std::string& src);
   void OnPluginDestroyed(int instance_id);
-  // Grab the new damage buffer from the embedder, and resize the guest's
-  // web contents.
-  void OnResizeGuest(int instance_id,
-                     const BrowserPluginHostMsg_ResizeGuest_Params& params);
-  // Overriden in tests.
+  // Resizes the guest's web contents.
+  // Overridden in tests.
+  virtual void OnResizeGuest(
+      int instance_id, const BrowserPluginHostMsg_ResizeGuest_Params& params);
+  // Overridden in tests.
   virtual void OnSetFocus(int instance_id, bool focused);
   // Sets the name of the guest so that other guests in the same partition can
   // access it.
   void OnSetName(int instance_id, const std::string& name);
   // Updates the size state of the guest.
   void OnSetSize(
       int instance_id,
       const BrowserPluginHostMsg_AutoSize_Params& auto_size_params,
       const BrowserPluginHostMsg_ResizeGuest_Params& resize_guest_params);
   void OnSetEditCommandsForNextKeyEvent(
@@ skipping 12 matching lines @@
   // resources such as dropping back buffers and adjusting memory limits (if in
   // compositing mode, see CCLayerTreeHost::setVisible).
   //
   // Additionally, it will slow down Javascript execution and garbage
   // collection. See RenderThreadImpl::IdleHandler (executed when hidden) and
   // RenderThreadImpl::IdleHandlerInForegroundTab (executed when visible).
   void OnSetVisibility(int instance_id, bool visible);
   void OnUnlockMouse();
   void OnUnlockMouseAck(int instance_id);
   void OnUpdateGeometry(int instance_id, const gfx::Rect& view_rect);
-  void OnUpdateRectACK(
-      int instance_id,
-      const BrowserPluginHostMsg_AutoSize_Params& auto_size_params,
-      const BrowserPluginHostMsg_ResizeGuest_Params& resize_guest_params);
 
   void OnTextInputTypeChanged(ui::TextInputType type,
                               ui::TextInputMode input_mode,
                               bool can_compose_inline);
   void OnImeSetComposition(
       int instance_id,
       const std::string& text,
       const std::vector<blink::WebCompositionUnderline>& underlines,
       int selection_start,
       int selection_end);
@@ skipping 17 matching lines @@
       blink::WebInputEvent::Type event_type,
       InputEventAckState ack_result);
   void OnHasTouchEventHandlers(bool accept);
   void OnSetCursor(const WebCursor& cursor);
   // On MacOSX popups are painted by the browser process. We handle them here
   // so that they are positioned correctly.
 #if defined(OS_MACOSX)
   void OnShowPopup(const ViewHostMsg_ShowPopup_Params& params);
 #endif
   void OnShowWidget(int route_id, const gfx::Rect& initial_pos);
-  // Overriden in tests.
+  // Overridden in tests.
   virtual void OnTakeFocus(bool reverse);
   void OnUpdateFrameName(int frame_id,
                          bool is_top_level,
                          const std::string& name);
   void OnUpdateRect(const ViewHostMsg_UpdateRect_Params& params);
 
   // Requests download permission through embedder JavaScript API after
   // retrieving url information from IO thread.
   void DidRetrieveDownloadURLFromRequestId(
       const std::string& request_method,
       const base::Callback<void(bool)>& callback,
       const GURL& url);
 
   // Forwards all messages from the |pending_messages_| queue to the embedder.
   void SendQueuedMessages();
 
   // Static factory instance (always NULL for non-test).
   static BrowserPluginHostFactory* factory_;
 
   scoped_ptr<EmbedderWebContentsObserver> embedder_web_contents_observer_;
   WebContentsImpl* embedder_web_contents_;
 
   // An identifier that uniquely identifies a browser plugin guest within an
   // embedder.
   int instance_id_;
-  scoped_ptr<base::SharedMemory> damage_buffer_;
-  // An identifier that uniquely identifies a damage buffer.
-  uint32 damage_buffer_sequence_id_;
-  size_t damage_buffer_size_;
-  gfx::Size damage_view_size_;
-  float damage_buffer_scale_factor_;
   float guest_device_scale_factor_;
   gfx::Rect guest_window_rect_;
   gfx::Rect guest_screen_rect_;
   base::TimeDelta guest_hang_timeout_;
   bool focused_;
   bool mouse_locked_;
   bool pending_lock_request_;
   bool guest_visible_;
   bool guest_opaque_;
   bool embedder_visible_;
   std::string name_;
   bool auto_size_enabled_;
   gfx::Size max_auto_size_;
   gfx::Size min_auto_size_;
+  gfx::Size full_size_;
 
   // Each copy-request is identified by a unique number. The unique number is
   // used to keep track of the right callback.
   int copy_request_id_;
   typedef base::Callback<void(bool, const SkBitmap&)> CopyRequestCallback;
   typedef std::map<int, const CopyRequestCallback> CopyRequestMap;
   CopyRequestMap copy_request_callbacks_;
 
   typedef std::map<BrowserPluginGuest*, NewWindowInfo> PendingWindowMap;
   PendingWindowMap pending_new_windows_;
@@ skipping 36 matching lines @@
   // Weak pointer used to ask GeolocationPermissionContext about geolocation
   // permission.
   base::WeakPtrFactory<BrowserPluginGuest> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserPluginGuest);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BROWSER_PLUGIN_BROWSER_PLUGIN_GUEST_H_