Change GpuDataManager to use Observer notifications rather than callbacks

chrome/browser/ui/webui/flash_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/flash_ui.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/callback_old.h"
 #include "base/i18n/time_formatting.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/crash_upload_list.h"
 #include "chrome/browser/plugin_prefs.h"
@@ skipping 35 matching lines @@
 const int kTimeout = 8 * 1000;  // 8 seconds.
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // FlashDOMHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // The handler for JavaScript messages for the about:flags page.
 class FlashDOMHandler : public WebUIMessageHandler,
-                        public CrashUploadList::Delegate {
+                        public CrashUploadList::Delegate,
+                        public GpuDataManager::Observer {
  public:
   FlashDOMHandler();
-  virtual ~FlashDOMHandler() {}
+  virtual ~FlashDOMHandler();
 
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   // CrashUploadList::Delegate implementation.
   virtual void OnCrashListAvailable() OVERRIDE;
 
+  // GpuDataManager::Observer implementation.
+  virtual void OnGpuInfoUpdate() OVERRIDE;
+
   // Callback for the "requestFlashInfo" message.
   void HandleRequestFlashInfo(const ListValue* args);
 
-  // Callback for the GPU information update.
-  void OnGpuInfoUpdate();
-
   // Callback for the Flash plugin information.
   void OnGotPlugins(const std::vector<webkit::WebPluginInfo>& plugins);
 
  private:
   // Called when we think we might have enough information to return data back
   // to the page.
   void MaybeRespondToPage();
 
   // In certain cases we might not get called back from the GPU process so we
   // set an upper limit on the time we wait. This function gets called when the
   // time has passed. This actually doesn't prevent the rest of the information
   // to appear later, the page will just reflow when more information becomes
   // available.
   void OnTimeout();
 
   // A timer to keep track of when the data fetching times out.
   base::OneShotTimer<FlashDOMHandler> timeout_;
 
   // GPU variables.
   GpuDataManager* gpu_data_manager_;
-  Callback0::Type* gpu_info_update_callback_;
 
   // Crash list.
   scoped_refptr<CrashUploadList> upload_list_;
 
   // Factory for the creating refs in callbacks.
   base::WeakPtrFactory<FlashDOMHandler> weak_ptr_factory_;
 
   // Whether the list of all crashes is available.
   bool crash_list_available_;
   // Whether the page has requested data.
@@ skipping 11 matching lines @@
       crash_list_available_(false),
       page_has_requested_data_(false),
       has_gpu_info_(false),
       has_plugin_info_(false) {
   // Request Crash data asynchronously.
   upload_list_ = CrashUploadList::Create(this);
   upload_list_->LoadCrashListAsynchronously();
 
   // Watch for changes in GPUInfo.
   gpu_data_manager_ = GpuDataManager::GetInstance();
-  gpu_info_update_callback_ =
-      NewCallback(this, &FlashDOMHandler::OnGpuInfoUpdate);
-  gpu_data_manager_->AddGpuInfoUpdateCallback(gpu_info_update_callback_);
+  gpu_data_manager_->AddObserver(this);
 
   // Tell GpuDataManager it should have full GpuInfo. If the
   // GPU process has not run yet, this will trigger its launch.
   gpu_data_manager_->RequestCompleteGpuInfoIfNeeded();
 
   // GPU access might not be allowed at all, which will cause us not to get a
   // call back.
   if (!gpu_data_manager_->GpuAccessAllowed())
     OnGpuInfoUpdate();
 
   PluginService::GetInstance()->GetPlugins(base::Bind(
       &FlashDOMHandler::OnGotPlugins, weak_ptr_factory_.GetWeakPtr()));
 
   // And lastly, we fire off a timer to make sure we never get stuck at the
   // "Loading..." message.
   timeout_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(kTimeout),
                  this, &FlashDOMHandler::OnTimeout);
 }
 
+FlashDOMHandler::~FlashDOMHandler() {
+  gpu_data_manager_->RemoveObserver(this);
+}
+
 void FlashDOMHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("requestFlashInfo",
       base::Bind(&FlashDOMHandler::HandleRequestFlashInfo,
                  base::Unretained(this)));
 }
 
 void FlashDOMHandler::OnCrashListAvailable() {
   crash_list_available_ = true;
   MaybeRespondToPage();
 }
@@ skipping 198 matching lines @@
   // Set up the about:flash source.
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
   profile->GetChromeURLDataManager()->AddDataSource(CreateFlashUIHTMLSource());
 }
 
 // static
 RefCountedMemory* FlashUI::GetFaviconResourceBytes() {
   // Use the default icon for now.
   return NULL;
 }