command_buffer: Implement glGetStringi for GL ES 3.0

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <map>
 #include <set>
 #include <sstream>
 #include <string>
 #include "base/compiler_specific.h"
+#include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/client/buffer_tracker.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gpu_control.h"
@@ skipping 93 matching lines @@
           base::SysInfo::AmountOfPhysicalMemory() > 1024 * 1024 * 1024
               ? base::saturated_cast<uint32_t>(
                     base::SysInfo::AmountOfPhysicalMemory() / 20)
               : 0),
 #endif
       error_message_callback_(NULL),
       current_trace_stack_(0),
       gpu_control_(gpu_control),
       capabilities_(gpu_control->GetCapabilities()),
       aggressively_free_resources_(false),
+      cached_extension_string_(nullptr),
       weak_ptr_factory_(this) {
   DCHECK(helper);
   DCHECK(transfer_buffer);
   DCHECK(gpu_control);
 
   std::stringstream ss;
   ss << std::hex << this;
   this_in_hex_ = ss.str();
 
   GPU_CLIENT_LOG_CODE_BLOCK({
@@ skipping 798 matching lines @@
     case GL_MAX_VERTEX_UNIFORM_COMPONENTS:
       *params = capabilities_.max_vertex_uniform_components;
       return true;
     case GL_MIN_PROGRAM_TEXEL_OFFSET:
       *params = capabilities_.min_program_texel_offset;
       return true;
     case GL_MINOR_VERSION:
       *params = capabilities_.minor_version;
       return true;
     case GL_NUM_EXTENSIONS:
-      *params = capabilities_.num_extensions;
+      UpdateCachedExtensionsIfNeeded();
+      *params = cached_extensions_.size();
       return true;
     case GL_NUM_PROGRAM_BINARY_FORMATS:
       *params = capabilities_.num_program_binary_formats;
       return true;
     case GL_PIXEL_PACK_BUFFER_BINDING:
       *params = bound_pixel_pack_buffer_;
       return true;
     case GL_PIXEL_UNPACK_BUFFER_BINDING:
       *params = bound_pixel_unpack_buffer_;
       return true;
@@ skipping 2327 matching lines @@
     }
     if (precision) {
       precision[0] = result->precision;
       GPU_CLIENT_LOG("  min_range: " << precision[0]);
     }
   }
   CheckGLError();
 }
 
 const GLubyte* GLES2Implementation::GetStringHelper(GLenum name) {
+  if (name == GL_EXTENSIONS && cached_extension_string_) {
+    return reinterpret_cast<const GLubyte*>(cached_extension_string_);
+  }
   const char* result = NULL;
   // Clears the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetString(name, kResultBucketId);
   std::string str;
   if (GetBucketAsString(kResultBucketId, &str)) {
     // Adds extensions implemented on client side only.
-    switch (name) {
-      case GL_EXTENSIONS:
-        str += std::string(str.empty() ? "" : " ") +
-            "GL_EXT_unpack_subimage "
-            "GL_CHROMIUM_map_sub";
-        if (capabilities_.image)
-          str += " GL_CHROMIUM_image GL_CHROMIUM_gpu_memory_buffer_image";
-        if (capabilities_.future_sync_points)
-          str += " GL_CHROMIUM_future_sync_point";
-        break;
-      default:
-        break;
+    if (name == GL_EXTENSIONS) {
+      str += std::string(str.empty() ? "" : " ") +
+             "GL_EXT_unpack_subimage "
+             "GL_CHROMIUM_map_sub";
+      if (capabilities_.image)
+        str += " GL_CHROMIUM_image GL_CHROMIUM_gpu_memory_buffer_image";
+      if (capabilities_.future_sync_points)
+        str += " GL_CHROMIUM_future_sync_point";
     }
 
     // Because of WebGL the extensions can change. We have to cache each unique
     // result since we don't know when the client will stop referring to a
     // previous one it queries.
-    GLStringMap::iterator it = gl_strings_.find(name);
-    if (it == gl_strings_.end()) {
-      std::set<std::string> strings;
-      std::pair<GLStringMap::iterator, bool> insert_result =
-          gl_strings_.insert(std::make_pair(name, strings));
-      DCHECK(insert_result.second);
-      it = insert_result.first;
-    }
-    std::set<std::string>& string_set = it->second;
-    std::set<std::string>::const_iterator sit = string_set.find(str);
-    if (sit != string_set.end()) {
-      result = sit->c_str();
-    } else {
-      std::pair<std::set<std::string>::const_iterator, bool> insert_result =
-          string_set.insert(str);
-      DCHECK(insert_result.second);
-      result = insert_result.first->c_str();
+    const std::string& cache = *gl_strings_.insert(str).first;

[piman, 2016/02/11 18:50:38]

Is it really advantageous to change gl_strings_ from a map to a set?
strings are more expensive to compare, and we would logically leak extension
strings when we call RequestExtensionCHROMIUM.

We could instead make the key in gl_strings_ a (name, index) pair, using e.g.
UINT32_MAX for unindexed ones. It would also remove the need for a separate
cached_extensions_ map.

[Kimmo Kinnunen, 2016/02/11 18:55:42]

It is changed from many sets to sets.
map of sets -> set
The exact idea is to leak those for eternity? I'm not following now...
I'm not following now at all.

Set is pretty optimal -- it contains each possible string that needs to be
retained for eternity, just once.

[piman, 2016/02/11 19:15:27]

Mmh, ok, I misread the former code. I was under the impression that
RequestExtensionCHROMIUM would cause the extension strings to be reset, but I
see that it's not the case. We can define RequestExtensionCHROMIUM however we
want, and I really wouldn't mind defining it as invalidating all the previously
returned GL_EXTENSIONS strings so that we don't need to leak anything. Extension
lists can be large, and this could become a lot of data when multiplied by every
combination of requested extensions. It's also only called by WebGL, and we can
certainly make sure WebGL knows how to deal with that.

+    result = cache.c_str();
+
+    if (name == GL_EXTENSIONS) {
+      cached_extension_string_ = result;
+      std::vector<std::string> extensions =
+          base::SplitString(cache, base::kWhitespaceASCII,
+                            base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+      for (auto extension : extensions) {
+        cached_extensions_.push_back(
+            gl_strings_.insert(extension).first->c_str());
+      }
     }
   }
   return reinterpret_cast<const GLubyte*>(result);
 }
 
 const GLubyte* GLES2Implementation::GetString(GLenum name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetString("
       << GLES2Util::GetStringStringType(name) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetString");
   const GLubyte* result = GetStringHelper(name);
   GPU_CLIENT_LOG("  returned " << reinterpret_cast<const char*>(result));
   CheckGLError();
   return result;
 }
 
+const GLubyte* GLES2Implementation::GetStringi(GLenum name, GLuint index) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetStringi("
+                     << GLES2Util::GetStringStringType(name) << "," << index
+                     << ")");
+  TRACE_EVENT0("gpu", "GLES2::GetStringi");
+  UpdateCachedExtensionsIfNeeded();
+  if (name != GL_EXTENSIONS) {
+    SetGLError(GL_INVALID_ENUM, "glGetStringi", "name");
+    return nullptr;
+  }
+  if (index >= cached_extensions_.size()) {
+    SetGLError(GL_INVALID_VALUE, "glGetStringi", "index too large");
+    return nullptr;
+  }
+
+  const char* result = cached_extensions_[index];
+  GPU_CLIENT_LOG("  returned " << result);
+  CheckGLError();
+  return reinterpret_cast<const GLubyte*>(result);
+}
+
 bool GLES2Implementation::GetTransformFeedbackVaryingHelper(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   typedef cmds::GetTransformFeedbackVarying::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return false;
   }
@@ skipping 1446 matching lines @@
   const char* result = NULL;
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetRequestableExtensionsCHROMIUM(kResultBucketId);
   std::string str;
   if (GetBucketAsString(kResultBucketId, &str)) {
     // The set of requestable extensions shrinks as we enable
     // them. Because we don't know when the client will stop referring
     // to a previous one it queries (see GetString) we need to cache
     // the unique results.
-    std::set<std::string>::const_iterator sit =
-        requestable_extensions_set_.find(str);
-    if (sit != requestable_extensions_set_.end()) {
-      result = sit->c_str();
-    } else {
-      std::pair<std::set<std::string>::const_iterator, bool> insert_result =
-          requestable_extensions_set_.insert(str);
-      DCHECK(insert_result.second);
-      result = insert_result.first->c_str();
-    }
+    result = gl_strings_.insert(str).first->c_str();
   }
   GPU_CLIENT_LOG("  returned " << result);
   return reinterpret_cast<const GLchar*>(result);
 }
 
 // TODO(gman): Remove this command. It's here for WebGL but is incompatible
 // with VirtualGL contexts.
 void GLES2Implementation::RequestExtensionCHROMIUM(const char* extension) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glRequestExtensionCHROMIUM("
                  << extension << ")");
+  InvalidateCachedExtensions();
   SetBucketAsCString(kResultBucketId, extension);
   helper_->RequestExtensionCHROMIUM(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 
   struct ExtensionCheck {
     const char* extension;
     ExtensionStatus* status;
   };
   const ExtensionCheck checks[] = {
     {
@@ skipping 1690 matching lines @@
     unsigned char* addr = static_cast<unsigned char*>(buffer.address());
     memcpy(addr, coeffs, coeffs_size);
 
     helper_->ProgramPathFragmentInputGenCHROMIUM(program, location, gen_mode,
                                                  components, buffer.shm_id(),
                                                  buffer.offset());
   }
   CheckGLError();
 }
 
+void GLES2Implementation::UpdateCachedExtensionsIfNeeded() {
+  if (cached_extension_string_) {
+    return;
+  }
+  GetStringHelper(GL_EXTENSIONS);
+}
+
+void GLES2Implementation::InvalidateCachedExtensions() {
+  cached_extension_string_ = nullptr;
+  cached_extensions_.clear();
+}
+
 // 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 "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu