Add initial GpuMemoryBufferSurfaceTexture implementation.

content/browser/renderer_host/compositor_impl_android.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_COMPOSITOR_IMPL_ANDROID_H_
 #define CONTENT_BROWSER_RENDERER_HOST_COMPOSITOR_IMPL_ANDROID_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/containers/scoped_ptr_hash_map.h"
@@ skipping 29 matching lines @@
       public ImageTransportFactoryAndroidObserver {
  public:
   CompositorImpl(CompositorClient* client, gfx::NativeWindow root_window);
   virtual ~CompositorImpl();
 
   static bool IsInitialized();
 
   // Returns the Java Surface object for a given view surface id.
   static jobject GetSurface(int surface_id);
 
+  // Returns the Java Surface object for a given surface texture id.
+  static jobject GetSurfaceTextureSurface(int surface_texture_id);
+
+  // Allocates a SurfaceTexture and returns a surface texture id. Returns -1
+  // on failure.
+  static int AllocateSurfaceTexture();

[epennerAtGoogle, 2014/03/12 00:45:06]

Could this and the above possibly be fused? Is the issue that the allocation
goes through our normal sync IPC and then GetSurfaceTextureSurface goes
synchronously through binder?  Even if so, why not do both at the same time?

A comment about this flow (and why) would help (for posterity).

[reveman, 2014/03/12 16:07:06]

surface_texture_id generation (giving the renderer the permission to allocate a
surface texture backed gpumemorybuffer) goes through normal IPC.

The actual creation of a SurfaceTexture instance doesn't have to be done at the
time of normal IPC but I didn't see any reason not to do that unless we remove
the normal IPC all together but I think that's a bad idea for the following
reasons:

1. The browser process should be able to decide what type of gpumemorybuffer to
give the renderer. I don't think we should make that decision in different
places depending on the platform.
2. One entry point in the browser process where permission to allocate
gpumemorybuffers are handled to maximize code reuse and make the flow easy to
understand.
It's in the design doc but I'll figure out how to make this clear in the code as
well.

+
   // Compositor implementation.
   virtual void SetRootLayer(scoped_refptr<cc::Layer> root) OVERRIDE;
   virtual void SetWindowSurface(ANativeWindow* window) OVERRIDE;
   virtual void SetSurface(jobject surface) OVERRIDE;
   virtual void SetVisible(bool visible) OVERRIDE;
   virtual void setDeviceScaleFactor(float factor) OVERRIDE;
   virtual void SetWindowBounds(const gfx::Size& size) OVERRIDE;
   virtual void SetHasTransparentBackground(bool flag) OVERRIDE;
   virtual bool CompositeAndReadback(
       void *pixels, const gfx::Rect& rect) OVERRIDE;
@@ skipping 56 matching lines @@
   UIResourceMap ui_resource_map_;
 
   gfx::NativeWindow root_window_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorImpl);
 };
 
 } // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_COMPOSITOR_IMPL_ANDROID_H_