aura: Remove old GL paths from RenderWidgetHostViewAura.

content/browser/renderer_host/render_widget_host_view_aura.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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 338 matching lines @@
     return frame_subscriber_.get();
   }
 
   virtual bool ShouldCreateResizeLock();
   virtual scoped_ptr<ResizeLock> CreateResizeLock(bool defer_compositor_lock);
 
   virtual void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
 
   // Exposed for tests.
   aura::Window* window() { return window_; }
-  gfx::Size current_frame_size() const { return current_frame_size_; }
+  gfx::Size current_frame_size_in_dip() const {
+    return current_frame_size_in_dip_;
+  }
   void LockResources();
   void UnlockResources();
 
   // Overridden from ui::CompositorObserver:
   virtual void OnCompositingDidCommit(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingStarted(ui::Compositor* compositor,
                                     base::TimeTicks start_time) OVERRIDE;
   virtual void OnCompositingEnded(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingAborted(ui::Compositor* compositor) OVERRIDE;
   virtual void OnCompositingLockStateChanged(
@@ skipping 46 matching lines @@
   // space is required by the aura::Window.
   void InternalSetBounds(const gfx::Rect& rect);
 
   // Lazily grab a resize lock if the aura window size doesn't match the current
   // frame size, to give time to the renderer.
   void MaybeCreateResizeLock();
 
   // Checks if the resize lock can be released because we received an new frame.
   void CheckResizeLock();
 
-  void UpdateExternalTexture();
   ui::InputMethod* GetInputMethod() const;
 
   // Returns whether the widget needs an input grab to work properly.
   bool NeedsInputGrab();
 
   // Confirm existing composition text in the webpage and ask the input method
   // to cancel its ongoing composition session.
   void FinishImeCompositionSession();
 
   // This method computes movementX/Y and keeps track of mouse location for
@@ skipping 69 matching lines @@
   // Dismisses a Web Popup on a mouse or touch press outside the popup and its
   // parent.
   void ApplyEventFilterForPopupExit(ui::LocatedEvent* event);
 
   // Converts |rect| from window coordinate to screen coordinate.
   gfx::Rect ConvertRectToScreen(const gfx::Rect& rect) const;
 
   // Converts |rect| from screen coordinate to window coordinate.
   gfx::Rect ConvertRectFromScreen(const gfx::Rect& rect) const;
 
-  typedef base::Callback<void(bool, const scoped_refptr<ui::Texture>&)>
-      BufferPresentedCallback;
-
-  // The common entry point for buffer updates from renderer
-  // and GPU process.
-  void BuffersSwapped(const gfx::Size& surface_size,
-                      const gfx::Rect& damage_rect,
-                      float surface_scale_factor,
-                      const std::string& mailbox_name,
-                      const std::vector<ui::LatencyInfo>& latency_info,
-                      const BufferPresentedCallback& ack_callback);
-
-  bool SwapBuffersPrepare(const gfx::Rect& surface_rect,
-                          float surface_scale_factor,
-                          const gfx::Rect& damage_rect,
-                          const std::string& mailbox_name,
-                          const BufferPresentedCallback& ack_callback);
-
-  void SwapBuffersCompleted(
-      const BufferPresentedCallback& ack_callback,
-      const scoped_refptr<ui::Texture>& texture_to_return);
-
   void SwapDelegatedFrame(
       uint32 output_surface_id,
       scoped_ptr<cc::DelegatedFrameData> frame_data,
       float frame_device_scale_factor,
       const std::vector<ui::LatencyInfo>& latency_info);
   void SendDelegatedFrameAck(uint32 output_surface_id);
   void SendReturnedDelegatedResources(uint32 output_surface_id);
 
   // DelegatedFrameEvictorClient implementation.
   virtual void EvictDelegatedFrame() OVERRIDE;
@@ skipping 71 matching lines @@
   bool has_composition_text_;
 
   // Whether return characters should be passed on to the RenderWidgetHostImpl.
   bool accept_return_character_;
 
   // Current tooltip text.
   base::string16 tooltip_;
 
   std::vector<base::Closure> on_compositing_did_commit_callbacks_;
 
-  // The current frontbuffer texture.
-  scoped_refptr<ui::Texture> current_surface_;
-
   // This holds the current software framebuffer, if any.
   scoped_ptr<SoftwareFrameManager> software_frame_manager_;
 
   // With delegated renderer, this is the last output surface, used to
   // disambiguate resources with the same id coming from different output
   // surfaces.
   uint32 last_output_surface_id_;
 
   // The number of delegated frame acks that are pending, to delay resource
   // returns until the acks are sent.
   int pending_delegated_ack_count_;
 
-  // The damage in the previously presented buffer.
-  SkRegion previous_damage_;
-
-  // Pending damage from previous frames that we skipped.
-  SkRegion skipped_damage_;
-
   // True after a delegated frame has been skipped, until a frame is not
   // skipped.
   bool skipped_frames_;
 
   // Holds delegated resources that have been given to a DelegatedFrameProvider,
   // and gives back resources when they are no longer in use for return to the
   // renderer.
   scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection_;
 
   // Provides delegated frame updates to the cc::DelegatedRendererLayer.
   scoped_refptr<cc::DelegatedFrameProvider> frame_provider_;
 
-  // The size of the last frame that was swapped (even if we skipped it).
-  // Used to determine when the skipped_damage_ needs to be reset due to
-  // size changes between front- and backbuffer.
-  gfx::Size last_swapped_surface_size_;
-  float last_swapped_surface_scale_factor_;
+  // The size and scale of the last software compositing frame that was swapped.
+  gfx::Size last_swapped_software_frame_size_;
+  float last_swapped_software_frame_scale_factor_;
 
   // If non-NULL we're in OnPaint() and this is the supplied canvas.
   gfx::Canvas* paint_canvas_;
 
   // Used to record the last position of the mouse.
   // While the mouse is locked, they store the last known position just as mouse
   // lock was entered.
   // Relative to the upper-left corner of the view.
   gfx::Point unlocked_mouse_position_;
   // Relative to the upper-left corner of the screen.
   gfx::Point unlocked_global_mouse_position_;
   // Last cursor position relative to screen. Used to compute movementX/Y.
   gfx::Point global_mouse_position_;
   // In mouse locked mode, we syntheticaly move the mouse cursor to the center
   // of the window when it reaches the window borders to avoid it going outside.
   // This flag is used to differentiate between these synthetic mouse move
   // events vs. normal mouse move events.
   bool synthetic_move_sent_;
 
-  // Signals that the accelerated compositing has been turned on or off.
-  // This is used to signal to turn off the external texture as soon as the
-  // software backing store is updated.
-  bool accelerated_compositing_state_changed_;
-
   // This lock is the one waiting for a frame of the right size to come back
   // from the renderer/GPU process. It is set from the moment the aura window
   // got resized, to the moment we committed the renderer frame of the same
   // size. It keeps track of the size we expect from the renderer, and locks the
   // compositor, as well as the UI for a short time to give a chance to the
   // renderer of producing a frame of the right size.
   scoped_ptr<ResizeLock> resize_lock_;
 
   // Keeps track of the current frame size.
-  gfx::Size current_frame_size_;
+  gfx::Size current_frame_size_in_dip_;
 
   // This lock is for waiting for a front surface to become available to draw.
   scoped_refptr<ui::CompositorLock> released_front_lock_;
 
   // Used to track the state of the window we're created from. Only used when
   // created fullscreen.
   scoped_ptr<aura::WindowTracker> host_tracker_;
 
   enum CanLockCompositorState {
     YES,
@@ skipping 61 matching lines @@
   // passed to windowless plugins like Flash/Silverlight, etc as the
   // container window.
   HWND plugin_parent_window_;
 #endif
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_