Revert 155218 - Move gpu blacklist to content side.

chrome/browser/ui/webui/tracing_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 "chrome/browser/ui/webui/tracing_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/gpu_blacklist.h"
+#include "chrome/browser/gpu_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "content/public/browser/gpu_data_manager_observer.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 33 matching lines @@
   return source;
 }
 
 // This class receives javascript messages from the renderer.
 // Note that the WebUI infrastructure runs on the UI thread, therefore all of
 // this class's methods are expected to run on the UI thread.
 class TracingMessageHandler
     : public WebUIMessageHandler,
       public ui::SelectFileDialog::Listener,
       public base::SupportsWeakPtr<TracingMessageHandler>,
-      public content::TraceSubscriber {
+      public content::TraceSubscriber,
+      public content::GpuDataManagerObserver {
  public:
   TracingMessageHandler();
   virtual ~TracingMessageHandler();
 
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages();
 
   // SelectFileDialog::Listener implementation
   virtual void FileSelected(const FilePath& path, int index, void* params);
   virtual void FileSelectionCanceled(void* params);
 
   // TraceSubscriber implementation.
   virtual void OnEndTracingComplete();
   virtual void OnTraceDataCollected(
       const scoped_refptr<base::RefCountedString>& trace_fragment);
   virtual void OnTraceBufferPercentFullReply(float percent_full);
 
+  // GpuDataManagerObserver implementation.
+  virtual void OnGpuInfoUpdate() OVERRIDE;
+  virtual void OnVideoMemoryUsageStatsUpdate(
+      const content::GPUVideoMemoryUsageStats& video_memory) OVERRIDE {}
+
   // Messages.
   void OnTracingControllerInitialized(const ListValue* list);
   void OnBeginTracing(const ListValue* list);
   void OnEndTracingAsync(const ListValue* list);
   void OnBeginRequestBufferPercentFull(const ListValue* list);
   void OnLoadTraceFile(const ListValue* list);
   void OnSaveTraceFile(const ListValue* list);
 
   // Callbacks.
   void LoadTraceFileComplete(string16* file_contents);
   void SaveTraceFileComplete();
 
  private:
   // The file dialog to select a file for loading or saving traces.
   scoped_refptr<ui::SelectFileDialog> select_trace_file_dialog_;
 
   // The type of the file dialog as the same one is used for loading or saving
   // traces.
   ui::SelectFileDialog::Type select_trace_file_dialog_type_;
 
   // The trace data that is to be written to the file on saving.
   scoped_ptr<std::string> trace_data_to_save_;
 
   // True while tracing is active.
   bool trace_enabled_;
 
   // True while system tracing is active.
   bool system_trace_in_progress_;
 
+  // True if observing the GpuDataManager (re-attaching as observer would
+  // DCHECK).
+  bool observing_;
+
   void OnEndSystemTracingAck(
       const scoped_refptr<base::RefCountedString>& events_str_ptr);
 
   DISALLOW_COPY_AND_ASSIGN(TracingMessageHandler);
 };
 
 // A proxy passed to the Read and Write tasks used when loading or saving trace
 // data.
 class TaskProxy : public base::RefCountedThreadSafe<TaskProxy> {
  public:
@@ skipping 22 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TracingMessageHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TracingMessageHandler::TracingMessageHandler()
     : select_trace_file_dialog_type_(ui::SelectFileDialog::SELECT_NONE),
       trace_enabled_(false),
-      system_trace_in_progress_(false) {
+      system_trace_in_progress_(false),
+      observing_(false) {
 }
 
 TracingMessageHandler::~TracingMessageHandler() {
+  GpuDataManager::GetInstance()->RemoveObserver(this);
+
   if (select_trace_file_dialog_)
     select_trace_file_dialog_->ListenerDestroyed();
 
   // If we are the current subscriber, this will result in ending tracing.
   TraceController::GetInstance()->CancelSubscriber(this);
 
   // Shutdown any system tracing too.
     if (system_trace_in_progress_) {
 #if defined(OS_CHROMEOS)
       chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->
@@ skipping 23 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("saveTraceFile",
       base::Bind(&TracingMessageHandler::OnSaveTraceFile,
                  base::Unretained(this)));
 }
 
 void TracingMessageHandler::OnTracingControllerInitialized(
     const ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  // Watch for changes in GPUInfo
+  if (!observing_)
+    GpuDataManager::GetInstance()->AddObserver(this);
+  observing_ = true;
+
+  // Tell GpuDataManager it should have full GpuInfo. If the
+  // Gpu process has not run yet, this will trigger its launch.
+  GpuDataManager::GetInstance()->RequestCompleteGpuInfoIfNeeded();
+
+  // Run callback immediately in case the info is ready and no update in the
+  // future.
+  OnGpuInfoUpdate();
+
   // Send the client info to the tracingController
   {
     scoped_ptr<DictionaryValue> dict(new DictionaryValue());
     chrome::VersionInfo version_info;
 
     if (!version_info.is_valid()) {
       DLOG(ERROR) << "Unable to create chrome::VersionInfo";
     } else {
       // We have everything we need to send the right values.
       dict->SetString("version", version_info.Version());
       dict->SetString("cl", version_info.LastChange());
       dict->SetString("version_mod",
           chrome::VersionInfo::GetVersionStringModifier());
       dict->SetString("official",
           l10n_util::GetStringUTF16(
               version_info.IsOfficialBuild() ?
               IDS_ABOUT_VERSION_OFFICIAL :
               IDS_ABOUT_VERSION_UNOFFICIAL));
 
       dict->SetString("command_line",
           CommandLine::ForCurrentProcess()->GetCommandLineString());
     }
 
     dict->SetString("blacklist_version",
-        GpuDataManager::GetInstance()->GetBlacklistVersion());
+        GpuBlacklist::GetInstance()->GetVersion());
     web_ui()->CallJavascriptFunction("tracingController.onClientInfoUpdate",
                                      *dict);
   }
 }
 
 void TracingMessageHandler::OnBeginRequestBufferPercentFull(
     const ListValue* list) {
   TraceController::GetInstance()->GetTraceBufferPercentFullAsync(this);
 }
 
+void TracingMessageHandler::OnGpuInfoUpdate() {
+  // Get GPU Info.
+  scoped_ptr<base::DictionaryValue> gpu_info_val(
+      gpu_util::GpuInfoAsDictionaryValue());
+
+  // Add in blacklisting features
+  Value* feature_status = gpu_util::GetFeatureStatus();
+  if (feature_status)
+    gpu_info_val->Set("featureStatus", feature_status);
+
+  // Send GPU Info to javascript.
+  web_ui()->CallJavascriptFunction("tracingController.onGpuInfoUpdate",
+      *(gpu_info_val.get()));
+}
+
 // A callback used for asynchronously reading a file to a string. Calls the
 // TaskProxy callback when reading is complete.
 void ReadTraceFileCallback(TaskProxy* proxy, const FilePath& path) {
   std::string file_contents;
   if (!file_util::ReadFileToString(path, &file_contents))
     return;
 
   // We need to escape the file contents, because it will go into a javascript
   // quoted string in TracingMessageHandler::LoadTraceFileComplete. We need to
   // escape control characters (to have well-formed javascript statements), as
@@ skipping 253 matching lines @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TracingUI::TracingUI(content::WebUI* web_ui) : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new TracingMessageHandler());
 
   // Set up the chrome://tracing/ source.
   Profile* profile = Profile::FromWebUI(web_ui);
   ChromeURLDataManager::AddDataSource(profile, CreateTracingHTMLSource());
 }