Enable creation of offscreen contexts which own their backing surface.

gpu/ipc/service/gpu_command_buffer_stub.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/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 548 matching lines @@
                                       decoder_.get()));
   sync_point_client_ = channel_->sync_point_manager()->CreateSyncPointClient(
       channel_->GetSyncPointOrderData(stream_id_),
       CommandBufferNamespace::GPU_IO, command_buffer_id_);
 
   executor_->SetPreemptByFlag(channel_->preempted_flag());
 
   decoder_->set_engine(executor_.get());
 
   if (offscreen) {
-    surface_ = default_surface;
+    if (init_params.attribs.own_offscreen_surface) {
+      use_virtualized_gl_context_ = false;
+      int depth = init_params.attribs.depth_size;
+      if (depth > 0) {
+        if (depth == 24 && surface_format == gl::GLSurface::SURFACE_ARGB8888) {
+          surface_format = gl::GLSurface::SURFACE_ARGB8888_DEPTH24;
+        } else if (depth == 24 &&
+                   surface_format == gl::GLSurface::SURFACE_RGB565) {
+          surface_format = gl::GLSurface::SURFACE_RGB565_DEPTH24;
+        } else {
+          DLOG(ERROR) << "Failed to create surface, can't add depth_size="
+                      << depth << " to base format " << surface_format;

[piman, 2016/11/16 00:44:02]

Should we fail initialization here, then? I.e. return false.

[dcheng, 2016/11/17 01:17:00]

+1, this is coming from the renderer right? We need to gracefully handle invalid
or otherwise impossible combinations here.

[klausw, 2017/01/05 02:17:43]

Please see the new logic, I think it's much cleaner now that it's
using a GLSurfaceFormat structure with Get/SetDepthBits() and related
accessors.

+        }
+      }
+      surface_ = gl::init::CreateUninitializedOffscreenGLSurface(gfx::Size());
+      if (!surface_ || !surface_->Initialize(surface_format)) {
+        surface_ = nullptr;
+        DLOG(ERROR) << "Failed to create surface.";
+        return false;
+      }
+    } else {
+      surface_ = default_surface;
+    }
   } else {
     surface_ = ImageTransportSurface::CreateNativeSurface(
         AsWeakPtr(), surface_handle_, surface_format);
     if (!surface_ || !surface_->Initialize(surface_format)) {
       surface_ = nullptr;
       DLOG(ERROR) << "Failed to create surface.";
       return false;
     }
   }
 
@@ skipping 564 matching lines @@
       command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
     decoder_->MarkContextLost(error::kUnknown);
   command_buffer_->SetParseError(error::kLostContext);
 }
 
 }  // namespace gpu