[DevTools] Filter any messages from previous sessions in DevToolsAgentHostImpl

content/browser/devtools/protocol/system_info_handler.cc

 // Copyright 2014 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/devtools/protocol/system_info_handler.h"
 
 #include "base/bind.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/public/browser/gpu_data_manager.h"
 #include "gpu/config/gpu_info.h"
@@ skipping 75 matching lines @@
 }
 
 }  // namespace
 
 class SystemInfoHandlerGpuObserver : public content::GpuDataManagerObserver {
  public:
   SystemInfoHandlerGpuObserver(base::WeakPtr<SystemInfoHandler> handler,
                                DevToolsCommandId command_id)
       : handler_(handler),
         command_id_(command_id),
-        observer_id_(++next_observer_id_)
-  {
+        observer_id_(++next_observer_id_) {
     if (handler_) {
       handler_->AddActiveObserverId(observer_id_);
     }
   }
 
   void OnGpuInfoUpdate() override {
     UnregisterAndSendResponse();
   }
 
   void OnGpuProcessCrashed(base::TerminationStatus exit_code) override {
@@ skipping 39 matching lines @@
   std::string reason;
   if (!GpuDataManager::GetInstance()->GpuAccessAllowed(&reason) ||
       GpuDataManager::GetInstance()->IsEssentialGpuInfoAvailable()) {
     // The GpuDataManager already has all of the information needed to make
     // GPU-based blacklisting decisions. Post a task to give it to the
     // client asynchronously.
     //
     // Waiting for complete GPU info in the if-test above seems to
     // frequently hit internal timeouts in the launching of the unsandboxed
     // GPU process in debug builds on Windows.
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&SystemInfoHandler::SendGetInfoResponse,
-                   weak_factory_.GetWeakPtr(),
-                   command_id));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&SystemInfoHandler::SendGetInfoResponse,
+                                       weak_factory_.GetWeakPtr(), command_id));
   } else {
     // We will be able to get more information from the GpuDataManager.
     // Register a transient observer with it to call us back when the
     // information is available.
     SystemInfoHandlerGpuObserver* observer = new SystemInfoHandlerGpuObserver(
         weak_factory_.GetWeakPtr(), command_id);
     BrowserThread::PostDelayedTask(
-        BrowserThread::UI,
-        FROM_HERE,
+        BrowserThread::UI, FROM_HERE,
         base::Bind(&SystemInfoHandler::ObserverWatchdogCallback,
-                   weak_factory_.GetWeakPtr(),
-                   observer->GetObserverId(),
+                   weak_factory_.GetWeakPtr(), observer->GetObserverId(),
                    command_id),
         base::TimeDelta::FromMilliseconds(kGPUInfoWatchdogTimeoutMs));
     GpuDataManager::GetInstance()->AddObserver(observer);
     // There's no other method available to request just essential GPU info.
     GpuDataManager::GetInstance()->RequestCompleteGpuInfoIfNeeded();
   }
 
   return Response::OK();
 }
 
 void SystemInfoHandler::SendGetInfoResponse(DevToolsCommandId command_id) {
   gpu::GPUInfo gpu_info = GpuDataManager::GetInstance()->GetGPUInfo();
   std::vector<scoped_refptr<GPUDevice>> devices;
   devices.push_back(GPUDeviceToProtocol(gpu_info.gpu));
   for (const auto& device : gpu_info.secondary_gpus)
     devices.push_back(GPUDeviceToProtocol(device));
 
   scoped_ptr<base::DictionaryValue> aux_attributes(new base::DictionaryValue);
   AuxGPUInfoEnumerator enumerator(aux_attributes.get());
   gpu_info.EnumerateFields(&enumerator);
 
   scoped_refptr<GPUInfo> gpu = GPUInfo::Create()
       ->set_devices(devices)
       ->set_aux_attributes(aux_attributes.Pass())
       ->set_feature_status(make_scoped_ptr(GetFeatureStatus()))
       ->set_driver_bug_workarounds(GetDriverBugWorkarounds());
 
   client_->SendGetInfoResponse(
-      command_id,
-      GetInfoResponse::Create()->set_gpu(gpu)
-      ->set_model_name(gpu_info.machine_model_name)
-      ->set_model_version(gpu_info.machine_model_version));
+      command_id, GetInfoResponse::Create()
+                      ->set_gpu(gpu)
+                      ->set_model_name(gpu_info.machine_model_name)
+                      ->set_model_version(gpu_info.machine_model_version));
 }
 
 void SystemInfoHandler::AddActiveObserverId(int observer_id) {
   base::AutoLock auto_lock(lock_);
   active_observers_.insert(observer_id);
 }
 
 bool SystemInfoHandler::RemoveActiveObserverId(int observer_id) {
   base::AutoLock auto_lock(lock_);
   int num_removed = active_observers_.erase(observer_id);
   return (num_removed != 0);
 }
 
 void SystemInfoHandler::ObserverWatchdogCallback(int observer_id,
                                                  DevToolsCommandId command_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (RemoveActiveObserverId(observer_id)) {
     SendGetInfoResponse(command_id);
     // For the time being we want to know about this event in the test logs.
     LOG(ERROR) << "SystemInfoHandler: request for GPU info timed out!"
                << " Most recent info sent.";
   }
 }
 
 }  // namespace system_info
 }  // namespace devtools
 }  // namespace content