Pass FROM_HERE to ObserverListThreadSafe::Notify to improve profile.

content/browser/gpu/gpu_data_manager_impl_private.cc

 // Copyright (c) 2013 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_impl_private.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 566 matching lines @@
   gpu::MergeGPUInfo(&gpu_info_, gpu_info);
   if (IsCompleteGpuInfoAvailable())
     complete_gpu_info_already_requested_ = true;
 
   UpdateGpuInfoHelper();
 }
 
 void GpuDataManagerImplPrivate::UpdateVideoMemoryUsageStats(
     const GPUVideoMemoryUsageStats& video_memory_usage_stats) {
   GpuDataManagerImpl::UnlockedSession session(owner_);
-  observer_list_->Notify(&GpuDataManagerObserver::OnVideoMemoryUsageStatsUpdate,
+  observer_list_->Notify(FROM_HERE,
+                         &GpuDataManagerObserver::OnVideoMemoryUsageStatsUpdate,
                          video_memory_usage_stats);
 }
 
 void GpuDataManagerImplPrivate::AppendRendererCommandLine(
     base::CommandLine* command_line) const {
   DCHECK(command_line);
 
   if (IsFeatureBlacklisted(gpu::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE) &&
       !command_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
     command_line->AppendSwitch(switches::kDisableAcceleratedVideoDecode);
@@ skipping 190 matching lines @@
         FROM_HERE,
         base::Bind(&GpuDataManagerImpl::ProcessCrashed,
                    base::Unretained(owner_),
                    exit_code));
     return;
   }
   {
     gpu_info_.process_crash_count = GpuProcessHost::gpu_crash_count();
     GpuDataManagerImpl::UnlockedSession session(owner_);
     observer_list_->Notify(
-        &GpuDataManagerObserver::OnGpuProcessCrashed, exit_code);
+        FROM_HERE, &GpuDataManagerObserver::OnGpuProcessCrashed, exit_code);
   }
 }
 
 base::ListValue* GpuDataManagerImplPrivate::GetLogMessages() const {
   base::ListValue* value = new base::ListValue;
   for (size_t ii = 0; ii < log_messages_.size(); ++ii) {
     base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetInteger("level", log_messages_[ii].level);
     dict->SetString("header", log_messages_[ii].header);
     dict->SetString("message", log_messages_[ii].message);
@@ skipping 182 matching lines @@
 
   if (ui::GpuSwitchingManager::GetInstance()->SupportsDualGpus()) {
     if (gpu_driver_bugs_.count(gpu::FORCE_DISCRETE_GPU) == 1)
       ui::GpuSwitchingManager::GetInstance()->ForceUseOfDiscreteGpu();
     else if (gpu_driver_bugs_.count(gpu::FORCE_INTEGRATED_GPU) == 1)
       ui::GpuSwitchingManager::GetInstance()->ForceUseOfIntegratedGpu();
   }
 }
 
 void GpuDataManagerImplPrivate::NotifyGpuInfoUpdate() {
-  observer_list_->Notify(&GpuDataManagerObserver::OnGpuInfoUpdate);
+  observer_list_->Notify(FROM_HERE, &GpuDataManagerObserver::OnGpuInfoUpdate);
 }
 
 void GpuDataManagerImplPrivate::EnableSwiftShaderIfNecessary() {
   if (ShouldUseWarp())
     return;
 
   if (!GpuAccessAllowed(NULL) ||
       blacklisted_features_.count(gpu::GPU_FEATURE_TYPE_WEBGL)) {
     if (!swiftshader_path_.empty() &&
         !base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 112 matching lines @@
 
 int64 GpuDataManagerImplPrivate::GetBlockAllDomainsDurationInMs() const {
   return kBlockAllDomainsMs;
 }
 
 void GpuDataManagerImplPrivate::Notify3DAPIBlocked(const GURL& url,
                                                    int render_process_id,
                                                    int render_view_id,
                                                    ThreeDAPIType requester) {
   GpuDataManagerImpl::UnlockedSession session(owner_);
-  observer_list_->Notify(&GpuDataManagerObserver::DidBlock3DAPIs,
+  observer_list_->Notify(FROM_HERE, &GpuDataManagerObserver::DidBlock3DAPIs,
                          url, render_process_id, render_view_id, requester);
 }
 
 void GpuDataManagerImplPrivate::OnGpuProcessInitFailure() {
   gpu_process_accessible_ = false;
   gpu_info_.context_info_state = gpu::kCollectInfoFatalFailure;
 #if defined(OS_WIN)
   gpu_info_.dx_diagnostics_info_state = gpu::kCollectInfoFatalFailure;
 #endif
   complete_gpu_info_already_requested_ = true;
   // Some observers might be waiting.
   NotifyGpuInfoUpdate();
 }
 
 }  // namespace content