WebVR: implement SetSurfaceHandleCHROMIUM extension for gvr_device.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 47 matching lines @@
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/sampler_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/transform_feedback_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
+#include "gpu/ipc/common/gpu_surface_lookup.h"
 #include "third_party/angle/src/image_util/loadimage.h"
 #include "third_party/smhasher/src/City.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/overlay_transform.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/ca_renderer_layer_params.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
+#include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/gl_version_info.h"
 #include "ui/gl/gpu_timing.h"
 
 #if defined(OS_MACOSX)
 #include <IOSurface/IOSurface.h>
 // Note that this must be included after gl_bindings.h to avoid conflicts.
 #include <OpenGL/CGLIOSurface.h>
 #endif
 
 namespace gpu {
@@ skipping 954 matching lines @@
 
   void DoMatrixLoadfCHROMIUM(GLenum matrix_mode,
                              const volatile GLfloat* matrix);
   void DoMatrixLoadIdentityCHROMIUM(GLenum matrix_mode);
   void DoScheduleCALayerInUseQueryCHROMIUM(GLsizei count,
                                            const volatile GLuint* textures);
 
   void DoFlushMappedBufferRange(
       GLenum target, GLintptr offset, GLsizeiptr size);
 
+  void DoSetSurfaceHandleCHROMIUM(GLint surface_handle);
+
   // Creates a Program for the given program.
   Program* CreateProgram(GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgram(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   Program* GetProgram(GLuint client_id) {
     return program_manager()->GetProgram(client_id);
   }
 
@@ skipping 1077 matching lines @@
   Error Handle##name(uint32_t immediate_data_size, const volatile void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
   scoped_refptr<gl::GLSurface> surface_;
   scoped_refptr<gl::GLContext> context_;
 
+  // WebVR data for switching and restoring the underlying destination surface.
+  scoped_refptr<gl::GLSurface> webvr_surface_;
+  scoped_refptr<gl::GLSurface> webvr_orig_surface_;
+  std::unique_ptr<BackFramebuffer> webvr_orig_offscreen_target_frame_buffer_;
+  bool webvr_orig_supports_async_swap_;
+
   // The ContextGroup for this decoder uses to track resources.
   scoped_refptr<ContextGroup> group_;
 
   DebugMarkerManager debug_marker_manager_;
   Logger logger_;
 
   // All the state for this context.
   ContextState state_;
 
   std::unique_ptr<TransformFeedbackManager> transform_feedback_manager_;
@@ skipping 14634 matching lines @@
       RestoreCurrentFramebufferBindings();
       if (LOCAL_PEEK_GL_ERROR("glApplyFramebufferAttachmentCMAAINTEL") !=
           GL_NO_ERROR)
         return;
     }
     apply_framebuffer_attachment_cmaa_intel_
         ->ApplyFramebufferAttachmentCMAAINTEL(this, bound_framebuffer);
   }
 }
 
+void GLES2DecoderImpl::DoSetSurfaceHandleCHROMIUM(GLint surface_handle) {

[bajones, 2016/10/28 00:41:22]

Looking at this implementation the function name is very generic but the
internals are very WebVR specific. Maybe we should change the name to reflect
that? Also the fact that it actually changes the framebuffer binding maybe
deserves a callout. BindWebVRSurfaceHandleCHROMIUM?

[bajones, 2016/10/28 16:47:46]

Oh, and I also realized last night that you're going to need to wrap the
majority of the code in this function in

#if defined(OS_ANDROID)

Since the file is compiled on all platforms but the code here uses
android-specific calls and types.

[klausw, 2016/11/08 02:18:30]

It no longer changes the framebuffer binding in this version.

Actually it's not really WebVR specific, it's functionality to rebind the
current context to draw directly to a surface. I've replaced "WebVR" with 
"direct render" in comments and member variables.

What do you think?

[klausw, 2016/11/08 02:18:30]

Done, and added an #else to raise a GL_INVALID_OPERATION on other platforms. Is
that the right way to do it?

+  if (surface_handle) {
+    // Use the specified surface as a render target, saving the offscreen
+    // render buffer so that we can restore it later.
+
+    // Ignore redundant calls. For now we don't support switching between
+    // different surfaces, if you need this you have to make a call with
+    // surface_handle=0 in between.
+    if (webvr_surface_) return;
+
+    // One-time initialization when first activating WebVR surface.
+    ANativeWindow* window =
+        gpu::GpuSurfaceLookup::GetInstance()->AcquireNativeWidget(
+            surface_handle);
+    webvr_surface_ = new gl::NativeViewGLSurfaceEGL(window);
+    // TODO(klausw): need to add a depth buffer for doing 3D rendering.
+    // Currently it's just used for a 2D copy.
+    bool initialize_success =
+        webvr_surface_->Initialize(gl::GLSurface::SURFACE_ARGB8888);
+    if (!initialize_success) {
+      LOG(ERROR) << "WebVR surface init failed, handle=" << surface_handle;
+    }
+    ANativeWindow_release(window);
+
+    webvr_orig_surface_ = surface_;
+
+    // We don't want async swap since we want full control over when the
+    // SurfaceTexture gets updated.
+    webvr_orig_supports_async_swap_ = supports_async_swap_;
+    supports_async_swap_ = false;
+
+    // Offscreen surfaces don't support SwapBuffers, make sure it's not
+    // considered offscreen. Various code in this file checks for is_offscreen
+    // = !!offscreen_target_frame_buffer_.get().
+    webvr_orig_offscreen_target_frame_buffer_ =
+        std::move(offscreen_target_frame_buffer_);
+    offscreen_target_frame_buffer_.reset(nullptr);
+
+    // Activate the surface, and use it for rendering.
+    SetSurface(webvr_surface_);
+    glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
+    glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
+    glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
+
+    // TODO(klausw): is any additional cleanup needed in destructor, or
+    // do smart pointers do the right thing already?
+  } else {
+    // Restore original state for drawing offscreen.
+
+    // Ignore redundant calls.
+    if (!webvr_surface_) return;
+
+    // TODO(klausw): check if this is sufficient cleanup, I'm assuming that
+    // clearing the smart pointer calls the appropriate destructor.
+    webvr_surface_ = nullptr;
+
+    supports_async_swap_ = webvr_orig_supports_async_swap_;
+
+    offscreen_target_frame_buffer_ =
+        std::move(webvr_orig_offscreen_target_frame_buffer_);
+    webvr_orig_offscreen_target_frame_buffer_.reset(nullptr);
+
+    SetSurface(webvr_orig_surface_);
+  }
+}
+
 void GLES2DecoderImpl::DoInsertEventMarkerEXT(
     GLsizei length, const GLchar* marker) {
   if (!marker) {
     marker = "";
   }
   debug_marker_manager_.SetMarker(
       length ? std::string(marker, length) : std::string(marker));
 }
 
 void GLES2DecoderImpl::DoPushGroupMarkerEXT(
@@ skipping 1840 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu