Change GpuDataManager to use Observer notifications rather than callbacks

content/browser/gpu/gpu_data_manager.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 "content/browser/gpu/gpu_data_manager.h"
 
 #if defined(OS_MACOSX)
 #include <CoreGraphics/CGDisplayConfiguration.h>
 #endif
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu/gpu_blacklist.h"
 #include "content/browser/gpu/gpu_process_host.h"
@@ skipping 159 matching lines @@
 }
 
 void GpuDataManager::UserFlags::ApplyPolicies() {
   if (disable_accelerated_compositing_) {
     disable_accelerated_2d_canvas_ = true;
     disable_accelerated_layers_ = true;
   }
 }
 
 GpuDataManager::GpuDataManager()
-    : complete_gpu_info_already_requested_(false) {
+    : complete_gpu_info_already_requested_(false),
+      observer_list_(new GpuDataManagerObserverList) {
   Initialize();
 }
 
 void GpuDataManager::Initialize() {
   // Certain tests doesn't go through the browser startup path that
   // initializes GpuDataManager on FILE thread; therefore, it is initialized
   // on UI thread later, and we skip the preliminary gpu info collection
   // in such situation.
   if (BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     content::GPUInfo gpu_info;
@@ skipping 31 matching lines @@
       new GpuMsg_CollectGraphicsInfo());
 }
 
 void GpuDataManager::UpdateGpuInfo(const content::GPUInfo& gpu_info) {
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     if (!Merge(&gpu_info_, gpu_info))
       return;
   }
 
-  RunGpuInfoUpdateCallbacks();
+  NotifyGpuInfoUpdate();
 
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     content::GetContentClient()->SetGpuInfo(gpu_info_);
   }
 
   UpdateGpuFeatureFlags();
 }
 
 const content::GPUInfo& GpuDataManager::gpu_info() const {
@@ skipping 150 matching lines @@
   if (UseGLIsOSMesaOrAny())
     return true;
 
   // We only need to block GPU process if more features are disallowed other
   // than those in the preliminary gpu feature flags because the latter work
   // through renderer commandline switches.
   uint32 mask = (~(preliminary_gpu_feature_flags_.flags()));
   return (gpu_feature_flags_.flags() & mask) == 0;
 }
 
-void GpuDataManager::AddGpuInfoUpdateCallback(Callback0::Type* callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  gpu_info_update_callbacks_.insert(callback);
+void GpuDataManager::AddObserver(Observer* observer) {
+  observer_list_->AddObserver(observer);
 }
 
-bool GpuDataManager::RemoveGpuInfoUpdateCallback(Callback0::Type* callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  std::set<Callback0::Type*>::iterator i =
-      gpu_info_update_callbacks_.find(callback);
-  if (i != gpu_info_update_callbacks_.end()) {
-    gpu_info_update_callbacks_.erase(i);
-    return true;
-  }
-  return false;
+void GpuDataManager::RemoveObserver(Observer* observer) {
+  observer_list_->RemoveObserver(observer);
 }
 
 void GpuDataManager::AppendRendererCommandLine(
     CommandLine* command_line) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(command_line);
 
   uint32 flags = gpu_feature_flags_.flags();
   if ((flags & GpuFeatureFlags::kGpuFeatureWebgl)) {
     if (!command_line->HasSwitch(switches::kDisableExperimentalWebGL))
@@ skipping 126 matching lines @@
   if (gpu_info().dx_diagnostics.children.size())
     dx_info = DxDiagNodeToList(gpu_info().dx_diagnostics);
   else
     dx_info = Value::CreateNullValue();
   info->Set("diagnostics", dx_info);
 #endif
 
   return info;
 }
 
-void GpuDataManager::RunGpuInfoUpdateCallbacks() {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &GpuDataManager::RunGpuInfoUpdateCallbacks));
-    return;
-  }
-
-  std::set<Callback0::Type*>::iterator i = gpu_info_update_callbacks_.begin();
-  for (; i != gpu_info_update_callbacks_.end(); ++i) {
-    (*i)->Run();
-  }
+void GpuDataManager::NotifyGpuInfoUpdate() {
+  observer_list_->Notify(&GpuDataManager::Observer::OnGpuInfoUpdate);
 }
 
 void GpuDataManager::UpdateGpuFeatureFlags() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        NewRunnableMethod(this, &GpuDataManager::UpdateGpuFeatureFlags));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&GpuDataManager::UpdateGpuFeatureFlags,
+                   base::Unretained(this)));

[James Hawkins, 2011/10/25 23:36:52]

Is base::Unretained() really needed here?  The conversion is from
NewRunnableMethod, which implies the ref-counting is desired.

[csilv, 2011/10/26 00:02:47]

So, in the original implementation NewRunnableMethod is not ref counting due to
use of:

  DISABLE_RUNNABLE_METHOD_REFCOUNT(GpuDataManager);

So that line needs to be deleted and thus the above represents a correct
migration.  GpuDataManger is a singleton so stays around until app exit.  The
alternative would be to make GpuDataManger a ref-counted object and then get rid
of the Unretained usage.

[James Hawkins, 2011/10/26 00:21:29]

Gotcha.

     return;
   }
 
   GpuBlacklist* gpu_blacklist = GetGpuBlacklist();
   // We don't set a lock around modifying gpu_feature_flags_ since it's just an
   // int.
   if (!gpu_blacklist) {
     gpu_feature_flags_.set_flags(0);
     return;
   }
 
   {
     base::AutoLock auto_lock(gpu_info_lock_);
     gpu_feature_flags_ = gpu_blacklist->DetermineGpuFeatureFlags(
         GpuBlacklist::kOsAny, NULL, gpu_info_);
   }
 
   // Notify clients that GpuInfo state has changed
-  RunGpuInfoUpdateCallbacks();
+  NotifyGpuInfoUpdate();
 
   uint32 flags = gpu_feature_flags_.flags();
   uint32 max_entry_id = gpu_blacklist->max_entry_id();
   bool disabled = false;
   if (flags == 0) {
     UMA_HISTOGRAM_ENUMERATION("GPU.BlacklistTestResultsPerEntry",
         0, max_entry_id + 1);
   } else {
     std::vector<uint32> flag_entries;
     gpu_blacklist->GetGpuFeatureFlagEntries(
@@ skipping 136 matching lines @@
 #if defined(OS_WIN)
     if (object->dx_diagnostics.values.size() == 0 &&
         object->dx_diagnostics.children.size() == 0) {
       object->dx_diagnostics = other.dx_diagnostics;
       changed = true;
     }
 #endif
   }
   return changed;
 }