Allow WebGL on Android if the GPU has it's own process

gpu/config/gpu_control_list.cc

 // Copyright (c) 2013 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/config/gpu_control_list.h"
 
 #include "base/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 705 matching lines @@
     }
     dictionary_entry_count++;
   }
 
   bool direct_rendering;
   if (value->GetBoolean("direct_rendering", &direct_rendering)) {
     entry->SetDirectRenderingInfo(direct_rendering);
     dictionary_entry_count++;
   }
 
+  bool in_process_gpu;
+  if (value->GetBoolean("in_process_gpu", &in_process_gpu)) {
+    entry->SetInProcessGPUInfo(in_process_gpu);
+    dictionary_entry_count++;
+  }
+
   if (top_level) {
     const base::ListValue* feature_value = NULL;
     if (value->GetList("features", &feature_value)) {
       std::vector<std::string> feature_list;
       for (size_t i = 0; i < feature_value->GetSize(); ++i) {
         std::string feature;
         if (feature_value->GetString(i, &feature)) {
           feature_list.push_back(feature);
         } else {
           LOG(WARNING) << "Malformed feature entry " << entry->id();
@@ skipping 237 matching lines @@
     const std::string& int_string,
     const std::string& int_string2) {
   gpu_count_info_.reset(new IntInfo(op, int_string, int_string2));
   return gpu_count_info_->IsValid();
 }
 
 void GpuControlList::GpuControlListEntry::SetDirectRenderingInfo(bool value) {
   direct_rendering_info_.reset(new BoolInfo(value));
 }
 
+void GpuControlList::GpuControlListEntry::SetInProcessGPUInfo(bool value) {
+  in_process_gpu_info_.reset(new BoolInfo(value));
+}
+
 bool GpuControlList::GpuControlListEntry::SetFeatures(
     const std::vector<std::string>& feature_strings,
     const FeatureMap& feature_map,
     bool supports_feature_type_all) {
   size_t size = feature_strings.size();
   if (size == 0)
     return false;
   features_.clear();
   for (size_t i = 0; i < size; ++i) {
     int feature = 0;
@@ skipping 243 matching lines @@
   if (machine_model_version_info_.get() != NULL &&
       (gpu_info.machine_model_version.empty() ||
        !machine_model_version_info_->Contains(gpu_info.machine_model_version)))
     return false;
   if (gpu_count_info_.get() != NULL &&
       !gpu_count_info_->Contains(gpu_info.secondary_gpus.size() + 1))
     return false;
   if (direct_rendering_info_.get() != NULL &&
       !direct_rendering_info_->Contains(gpu_info.direct_rendering))
     return false;
+  if (in_process_gpu_info_.get() != NULL &&
+      !in_process_gpu_info_->Contains(gpu_info.in_process_gpu))
+    return false;
   if (!cpu_brand_.empty()) {
     base::CPU cpu_info;
     if (StringMismatch(cpu_info.cpu_brand(), cpu_brand_))
       return false;
   }
 
   for (size_t i = 0; i < exceptions_.size(); ++i) {
     if (exceptions_[i]->Contains(os_type, os_version, gpu_info) &&
         !exceptions_[i]->NeedsMoreInfo(gpu_info, true))
       return false;
@@ skipping 309 matching lines @@
     const std::string& feature_name, int feature_id) {
   feature_map_[feature_name] = feature_id;
 }
 
 void GpuControlList::set_supports_feature_type_all(bool supported) {
   supports_feature_type_all_ = supported;
 }
 
 }  // namespace gpu