Move GPU device/driver info related code from content to gpu.

content/browser/gpu/gpu_internals_ui.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 "content/browser/gpu/gpu_internals_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "cc/base/switches.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/compositor_util.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
-#include "content/public/common/gpu_feature_type.h"
-#include "content/public/common/gpu_info.h"
 #include "content/public/common/url_constants.h"
+#include "gpu/config/gpu_feature_type.h"
+#include "gpu/config/gpu_info.h"
 #include "grit/content_resources.h"
 #include "third_party/angle/src/common/version.h"
 
 namespace content {
 namespace {
 
 struct GpuFeatureInfo {
   std::string name;
   uint32 blocked;
   bool disabled;
@@ skipping 28 matching lines @@
 
 base::Value* NewStatusValue(const char* name, const char* status) {
   base::DictionaryValue* value = new base::DictionaryValue();
   value->SetString("name", name);
   value->SetString("status", status);
   return value;
 }
 
 #if defined(OS_WIN)
 // Output DxDiagNode tree as nested array of {description,value} pairs
-base::ListValue* DxDiagNodeToList(const DxDiagNode& node) {
+base::ListValue* DxDiagNodeToList(const gpu::DxDiagNode& node) {
   base::ListValue* list = new ListValue();
   for (std::map<std::string, std::string>::const_iterator it =
       node.values.begin();
       it != node.values.end();
       ++it) {
     list->Append(NewDescriptionValuePair(it->first, it->second));
   }
 
-  for (std::map<std::string, DxDiagNode>::const_iterator it =
+  for (std::map<std::string, gpu::DxDiagNode>::const_iterator it =
       node.children.begin();
       it != node.children.end();
       ++it) {
     base::ListValue* sublist = DxDiagNodeToList(it->second);
     list->Append(NewDescriptionValuePair(it->first, sublist));
   }
   return list;
 }
 #endif
 
-std::string GPUDeviceToString(const GPUInfo::GPUDevice& gpu) {
+std::string GPUDeviceToString(const gpu::GPUInfo::GPUDevice& gpu) {
   std::string vendor = base::StringPrintf("0x%04x", gpu.vendor_id);
   if (!gpu.vendor_string.empty())
     vendor += " [" + gpu.vendor_string + "]";
   std::string device = base::StringPrintf("0x%04x", gpu.device_id);
   if (!gpu.device_string.empty())
     device += " [" + gpu.device_string + "]";
   return base::StringPrintf(
       "VENDOR = %s, DEVICE= %s", vendor.c_str(), device.c_str());
 }
 
 base::DictionaryValue* GpuInfoAsDictionaryValue() {
-  GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
+  gpu::GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
   base::ListValue* basic_info = new base::ListValue();
   basic_info->Append(NewDescriptionValuePair(
       "Initialization time",
       base::Int64ToString(gpu_info.initialization_time.InMilliseconds())));
   basic_info->Append(NewDescriptionValuePair(
       "Sandboxed", new base::FundamentalValue(gpu_info.sandboxed)));
   basic_info->Append(NewDescriptionValuePair(
       "GPU0", GPUDeviceToString(gpu_info.gpu)));
   for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
     basic_info->Append(NewDescriptionValuePair(
@@ skipping 73 matching lines @@
   GpuDataManagerImpl* manager = GpuDataManagerImpl::GetInstance();
   std::string gpu_access_blocked_reason;
   bool gpu_access_blocked =
       !manager->GpuAccessAllowed(&gpu_access_blocked_reason);
 
   base::DictionaryValue* status = new base::DictionaryValue();
 
   const GpuFeatureInfo kGpuFeatureInfo[] = {
       {
           "2d_canvas",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS),
+          manager->IsFeatureBlacklisted(
+              gpu::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS),
           command_line.HasSwitch(switches::kDisableAccelerated2dCanvas) ||
           !SupportsAccelerated2dCanvas(),
           "Accelerated 2D canvas is unavailable: either disabled at the command"
           " line or not supported by the current system.",
           true
       },
       {
           "compositing",
           manager->IsFeatureBlacklisted(
-              GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING),
+              gpu::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING),
           command_line.HasSwitch(switches::kDisableAcceleratedCompositing),
           "Accelerated compositing has been disabled, either via about:flags or"
           " command line. This adversely affects performance of all hardware"
           " accelerated features.",
           true
       },
       {
           "3d_css",
           manager->IsFeatureBlacklisted(
-              GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING) ||
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_3D_CSS),
+              gpu::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING) ||
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_3D_CSS),
           command_line.HasSwitch(switches::kDisableAcceleratedLayers),
           "Accelerated layers have been disabled at the command line.",
           false
       },
       {
           "css_animation",
           manager->IsFeatureBlacklisted(
-              GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING) ||
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_3D_CSS),
+              gpu::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING) ||
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_3D_CSS),
           command_line.HasSwitch(cc::switches::kDisableThreadedAnimation) ||
           command_line.HasSwitch(switches::kDisableAcceleratedCompositing) ||
           command_line.HasSwitch(switches::kDisableAcceleratedLayers),
           "Accelerated CSS animation has been disabled at the command line.",
           true
       },
       {
           "webgl",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_WEBGL),
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_WEBGL),
 #if defined(OS_ANDROID)
           !command_line.HasSwitch(switches::kEnableExperimentalWebGL),
 #else
           command_line.HasSwitch(switches::kDisableExperimentalWebGL),
 #endif
           "WebGL has been disabled, either via about:flags or command line.",
           false
       },
       {
           "multisampling",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_MULTISAMPLING),
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_MULTISAMPLING),
           command_line.HasSwitch(switches::kDisableGLMultisampling),
           "Multisampling has been disabled, either via about:flags or command"
           " line.",
           false
       },
       {
           "flash_3d",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_FLASH3D),
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_FLASH3D),
           command_line.HasSwitch(switches::kDisableFlash3d),
           "Using 3d in flash has been disabled, either via about:flags or"
           " command line.",
           false
       },
       {
           "flash_stage3d",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_FLASH_STAGE3D),
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_FLASH_STAGE3D),
           command_line.HasSwitch(switches::kDisableFlashStage3d),
           "Using Stage3d in Flash has been disabled, either via about:flags or"
           " command line.",
           false
       },
       {
           "flash_stage3d_baseline",
           manager->IsFeatureBlacklisted(
-              GPU_FEATURE_TYPE_FLASH_STAGE3D_BASELINE) ||
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_FLASH_STAGE3D),
+              gpu::GPU_FEATURE_TYPE_FLASH_STAGE3D_BASELINE) ||
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_FLASH_STAGE3D),
           command_line.HasSwitch(switches::kDisableFlashStage3d),
           "Using Stage3d Baseline profile in Flash has been disabled, either"
           " via about:flags or command line.",
           false
       },
       {
           "texture_sharing",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_TEXTURE_SHARING),
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_TEXTURE_SHARING),
           command_line.HasSwitch(switches::kDisableImageTransportSurface),
           "Sharing textures between processes has been disabled, either via"
           " about:flags or command line.",
           false
       },
       {
           "video_decode",
           manager->IsFeatureBlacklisted(
-              GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE),
+              gpu::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE),
           command_line.HasSwitch(switches::kDisableAcceleratedVideoDecode),
           "Accelerated video decode has been disabled, either via about:flags"
           " or command line.",
           true
       },
       {
           "video",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_ACCELERATED_VIDEO),
+          manager->IsFeatureBlacklisted(
+              gpu::GPU_FEATURE_TYPE_ACCELERATED_VIDEO),
           command_line.HasSwitch(switches::kDisableAcceleratedVideo) ||
           command_line.HasSwitch(switches::kDisableAcceleratedCompositing),
           "Accelerated video presentation has been disabled, either via"
           " about:flags or command line.",
           true
       },
       {
           "panel_fitting",
-          manager->IsFeatureBlacklisted(GPU_FEATURE_TYPE_PANEL_FITTING),
+          manager->IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_PANEL_FITTING),
 #if defined(OS_CHROMEOS)
           command_line.HasSwitch(switches::kDisablePanelFitting),
 #else
           true,
 #endif
           "Panel fitting is unavailable, either disabled at the command"
           " line or not supported by the current system.",
           false
       },
       {
           "force_compositing_mode",
           manager->IsFeatureBlacklisted(
-              GPU_FEATURE_TYPE_FORCE_COMPOSITING_MODE) &&
+              gpu::GPU_FEATURE_TYPE_FORCE_COMPOSITING_MODE) &&
           !IsForceCompositingModeEnabled(),
           !IsForceCompositingModeEnabled() &&
           !manager->IsFeatureBlacklisted(
-              GPU_FEATURE_TYPE_FORCE_COMPOSITING_MODE),
+              gpu::GPU_FEATURE_TYPE_FORCE_COMPOSITING_MODE),
           "Force compositing mode is off, either disabled at the command"
           " line or not supported by the current system.",
           false
       },
       {
           "raster",
           false,
           !command_line.HasSwitch(switches::kEnableAcceleratedPainting),
           "Accelerated rasterization has not been enabled or"
           " is not supported by the current system.",
@@ skipping 34 matching lines @@
         status = "unavailable";
         if (kGpuFeatureInfo[i].fallback_to_software)
           status += "_software";
         else
           status += "_off";
       } else {
         status = "enabled";
         if (kGpuFeatureInfo[i].name == "webgl" &&
             (command_line.HasSwitch(switches::kDisableAcceleratedCompositing) ||
              manager->IsFeatureBlacklisted(
-                 GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)))
+                 gpu::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)))
           status += "_readback";
         bool has_thread = IsThreadedCompositingEnabled();
         if (kGpuFeatureInfo[i].name == "compositing") {
           bool force_compositing = IsForceCompositingModeEnabled();
           if (force_compositing)
             status += "_force";
           if (has_thread)
             status += "_threaded";
         }
         if (kGpuFeatureInfo[i].name == "css_animation") {
           if (has_thread)
             status = "accelerated_threaded";
           else
             status = "accelerated";
         }
       }
       // TODO(reveman): Remove this when crbug.com/223286 has been fixed.
       if (kGpuFeatureInfo[i].name == "raster" &&
           cc::switches::IsImplSidePaintingEnabled()) {
         status = "disabled_software_multithreaded";
       }
       feature_status_list->Append(
           NewStatusValue(kGpuFeatureInfo[i].name.c_str(), status.c_str()));
     }
-    GpuSwitchingOption gpu_switching_option =
+    gpu::GpuSwitchingOption gpu_switching_option =
         GpuDataManagerImpl::GetInstance()->GetGpuSwitchingOption();
-    if (gpu_switching_option != GPU_SWITCHING_OPTION_UNKNOWN) {
+    if (gpu_switching_option != gpu::GPU_SWITCHING_OPTION_UNKNOWN) {
       std::string gpu_switching;
       switch (gpu_switching_option) {
-        case GPU_SWITCHING_OPTION_AUTOMATIC:
+      case gpu::GPU_SWITCHING_OPTION_AUTOMATIC:
           gpu_switching = "gpu_switching_automatic";
           break;
-        case GPU_SWITCHING_OPTION_FORCE_DISCRETE:
+      case gpu::GPU_SWITCHING_OPTION_FORCE_DISCRETE:
           gpu_switching = "gpu_switching_force_discrete";
           break;
-        case GPU_SWITCHING_OPTION_FORCE_INTEGRATED:
+      case gpu::GPU_SWITCHING_OPTION_FORCE_INTEGRATED:
           gpu_switching = "gpu_switching_force_integrated";
           break;
         default:
           break;
       }
       feature_status_list->Append(
           NewStatusValue("gpu_switching", gpu_switching.c_str()));
     }
     status->Set("featureStatus", feature_status_list);
   }
@@ skipping 211 matching lines @@
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new GpuMessageHandler());
 
   // Set up the chrome://gpu/ source.
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, CreateGpuHTMLSource());
 }
 
 }  // namespace content