Change GpuDataManager to use Observer notifications rather than callbacks

chrome/browser/ui/webui/tracing_ui.cc

 // Copyright (c) 2011 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/callback_old.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/shell_dialogs.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"
@@ skipping 19 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 SelectFileDialog::Listener,
       public base::SupportsWeakPtr<TracingMessageHandler>,
-      public TraceSubscriber {
+      public TraceSubscriber,
+      public GpuDataManager::Observer {
  public:
   TracingMessageHandler();
   virtual ~TracingMessageHandler();
 
   // WebUIMessageHandler implementation.
   virtual WebUIMessageHandler* Attach(WebUI* web_ui);
   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 std::string& trace_fragment);
   virtual void OnTraceBufferPercentFullReply(float percent_full);
 
+  // GpuDataManager::Observer implementation.
+  virtual void OnGpuInfoUpdate() 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 OnGpuInfoUpdate();
-
-  // Callbacks.
   void LoadTraceFileComplete(std::string* file_contents);
   void SaveTraceFileComplete();
 
  private:
   // The file dialog to select a file for loading or saving traces.
   scoped_refptr<SelectFileDialog> select_trace_file_dialog_;
 
   // The type of the file dialog as the same one is used for loading or saving
   // traces.
   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_;
 
   // Cache the Singleton for efficiency.
   GpuDataManager* gpu_data_manager_;
 
-  // Callback called when the GPU info is updated.
-  Callback0::Type* gpu_info_update_callback_;
-
   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:
   explicit TaskProxy(const base::WeakPtr<TracingMessageHandler>& handler)
       : handler_(handler) {}
   void LoadTraceFileCompleteProxy(std::string* file_contents) {
@@ skipping 17 matching lines @@
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TracingMessageHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TracingMessageHandler::TracingMessageHandler()
   : select_trace_file_dialog_type_(SelectFileDialog::SELECT_NONE),
-    trace_enabled_(false),
-    gpu_info_update_callback_(NULL) {
+    trace_enabled_(false) {
   gpu_data_manager_ = GpuDataManager::GetInstance();
   DCHECK(gpu_data_manager_);
 }
 
 TracingMessageHandler::~TracingMessageHandler() {
-  if (gpu_info_update_callback_) {
-    gpu_data_manager_->RemoveGpuInfoUpdateCallback(gpu_info_update_callback_);
-    delete gpu_info_update_callback_;
-  }
+  gpu_data_manager_->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);
 }
 
 WebUIMessageHandler* TracingMessageHandler::Attach(WebUI* web_ui) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 21 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));
 
-  DCHECK(!gpu_info_update_callback_);
-
   // Watch for changes in GPUInfo
-  gpu_info_update_callback_ =
-      NewCallback(this, &TracingMessageHandler::OnGpuInfoUpdate);
-  gpu_data_manager_->AddGpuInfoUpdateCallback(gpu_info_update_callback_);
+  gpu_data_manager_->AddObserver(this);

[Zhenyao Mo, 2011/10/26 00:03:12]

Since we always call RemoveObserver() in destructor, we should move AddObserver
to constructor.

[csilv, 2011/10/26 00:16:14]

This is actually a better approach to do it here.  This way, the callback will
only be invoked after the page is loaded.  If we move this to the constructor,
it may result in the handler trying to execute a javascript function before the
page is ready which yeilds a javascript error.

There's no harm in calling RemoveObserver if it was never added.

 
   // Tell GpuDataManager it should have full GpuInfo. If the
   // Gpu process has not run yet, this will trigger its launch.
   gpu_data_manager_->RequestCompleteGpuInfoIfNeeded();
 
   // Run callback immediately in case the info is ready and no update in the
   // future.
   OnGpuInfoUpdate();
 
   // Send the client info to the tracingController
@@ skipping 242 matching lines @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TracingUI::TracingUI(TabContents* contents) : ChromeWebUI(contents) {
   AddMessageHandler((new TracingMessageHandler())->Attach(this));
 
   // Set up the chrome://tracing/ source.
   Profile::FromBrowserContext(contents->browser_context())->
       GetChromeURLDataManager()->AddDataSource(CreateTracingHTMLSource());
 }