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 933 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_;
 
+  // Direct render mode data for switching and restoring the
+  // underlying destination surface, cf. DoSetSurfaceHandleCHROMIUM.
+  scoped_refptr<gl::GLSurface> direct_render_surface_;
+  scoped_refptr<gl::GLSurface> direct_render_orig_surface_;
+  std::unique_ptr<BackFramebuffer>
+      direct_render_orig_offscreen_target_frame_buffer_;
+  bool direct_render_orig_supports_async_swap_;
+  bool direct_render_orig_back_buffer_has_depth_;
+
   // 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 14772 matching lines @@
     static const char kFunctionName[] =
         "glApplyScreenSpaceAntialiasingCHROMIUM";
     if (!InitializeCopyTextureCHROMIUM(kFunctionName))
       return;
     apply_framebuffer_attachment_cmaa_intel_
         ->ApplyFramebufferAttachmentCMAAINTEL(this, bound_framebuffer,
                                               copy_texture_CHROMIUM_.get());
   }
 }
 
+void GLES2DecoderImpl::DoSetSurfaceHandleCHROMIUM(GLint surface_handle) {
+#if defined(OS_ANDROID)
+  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 (direct_render_surface_) {
+      return;
+    }
+
+    // One-time initialization when first activating a direct draw surface.
+    ANativeWindow* window =
+        gpu::GpuSurfaceLookup::GetInstance()->AcquireNativeWidget(
+            surface_handle);
+    direct_render_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 =
+        direct_render_surface_->Initialize(gl::GLSurface::SURFACE_ARGB8888);

[bajones, 2016/11/08 05:17:01]

The format of this surface should be the same as the format of the existing
surface, right? Should we pass surface_->GetFormat() instead of the static
ARGB8888?

[klausw, 2016/11/08 18:45:05]

Yes, done, and added a comment explaining why we can't change the format here.

+    if (!initialize_success) {
+      LOG(ERROR) << "Direct render surface init failed for handle " <<
+          surface_handle;
+    }
+    ANativeWindow_release(window);
+
+    direct_render_orig_surface_ = surface_;
+
+    // We don't want async swap since we want full control over when the
+    // SurfaceTexture gets updated.
+    direct_render_orig_supports_async_swap_ = supports_async_swap_;
+    supports_async_swap_ = false;
+    direct_render_orig_back_buffer_has_depth_ = back_buffer_has_depth_;
+    back_buffer_has_depth_ = true;
+    // override back_buffer_has_stencil_ too?
+
+    // 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().
+    direct_render_orig_offscreen_target_frame_buffer_ =
+        std::move(offscreen_target_frame_buffer_);
+    offscreen_target_frame_buffer_.reset(nullptr);
+
+    // Activate the surface. This does *not* rebind the active framebuffer,
+    // callers must do so themselves.
+    SetSurface(direct_render_surface_);
+
+    // 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 (!direct_render_surface_) return;
+
+    // TODO(klausw): check if this is sufficient cleanup, I'm assuming that
+    // clearing the smart pointer calls the appropriate destructor.

[bajones, 2016/11/08 05:17:01]

Correct. The smart pointers will call the destructor.

[klausw, 2016/11/08 18:45:05]

OK, removed the comment.

+    direct_render_surface_ = nullptr;
+
+    supports_async_swap_ = direct_render_orig_supports_async_swap_;
+    back_buffer_has_depth_ = direct_render_orig_back_buffer_has_depth_;
+
+    offscreen_target_frame_buffer_ =
+        std::move(direct_render_orig_offscreen_target_frame_buffer_);
+    direct_render_orig_offscreen_target_frame_buffer_.reset(nullptr);
+
+    SetSurface(direct_render_orig_surface_);
+  }
+#else  // !OS_ANDROID
+  LOCAL_SET_GL_ERROR(
+      GL_INVALID_OPERATION,
+      "glSetSurfaceHandleCHROMIUM",
+      "Direct render surface is unsupported on this platform");
+#endif
+}
+
 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 1846 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