Make RenderWidgetHostViewAura::CopyFromCompositingSurface readback layer

ui/compositor/layer.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 UI_COMPOSITOR_LAYER_H_
 #define UI_COMPOSITOR_LAYER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 13 matching lines @@
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_delegate.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
 class SkCanvas;
 
 namespace cc {
 class ContentLayer;
+class CopyOutputRequest;
 class DelegatedFrameData;
 class DelegatedRendererLayer;
 class Layer;
 class ResourceUpdateQueue;
 class SolidColorLayer;
 class TextureLayer;
 struct TransferableResource;
 typedef std::vector<TransferableResource> TransferableResourceArray;
 }
 
@@ skipping 209 matching lines @@
 
   // Set new TextureMailbox for this layer. Note that |mailbox| may hold a
   // shared memory resource or an actual mailbox for a texture.
   void SetTextureMailbox(const cc::TextureMailbox& mailbox, float scale_factor);
   cc::TextureMailbox GetTextureMailbox(float* scale_factor);
 
   // Sets a delegated frame, coming from a child compositor.
   void SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame,
                          gfx::Size frame_size_in_dip);
 
+  bool has_external_content() {
+    return texture_layer_.get() || delegated_renderer_layer_.get();
+  }
+
   // Gets unused resources to recycle to the child compositor.
   void TakeUnusedResourcesForChildCompositor(
       cc::TransferableResourceArray* array);
 
   // Sets the layer's fill color.  May only be called for LAYER_SOLID_COLOR.
   void SetColor(SkColor color);
 
   // Adds |invalid_rect| to the Layer's pending invalid rect and calls
   // ScheduleDraw(). Returns false if the paint request is ignored.
   bool SchedulePaint(const gfx::Rect& invalid_rect);
@@ skipping 22 matching lines @@
   // not apply to the canvas passed to the pending draw.
   void set_scale_content(bool scale_content) { scale_content_ = scale_content; }
 
   // Returns true if the layer scales its content.
   bool scale_content() const { return scale_content_; }
 
   // Sometimes the Layer is being updated by something other than SetCanvas
   // (e.g. the GPU process on UI_COMPOSITOR_IMAGE_TRANSPORT).
   bool layer_updated_externally() const { return layer_updated_externally_; }
 
+  // Requets a copy of the layer's output as a texture or bitmap.
+  void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request);
+
   // ContentLayerClient
   virtual void PaintContents(
       SkCanvas* canvas, gfx::Rect clip, gfx::RectF* opaque) OVERRIDE;
   virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
 
   cc::Layer* cc_layer() { return cc_layer_; }
 
   // TextureLayerClient
   virtual unsigned PrepareTexture(cc::ResourceUpdateQueue* queue) OVERRIDE;
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE;
@@ skipping 162 matching lines @@
   // The size of the delegated frame in DIP, set when SetDelegatedFrame was
   // called.
   gfx::Size delegated_frame_size_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_