[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 72 matching lines @@
                             ->set_device_id(device.device_id)
                             ->set_vendor_string(device.vendor_string)
                             ->set_device_string(device.device_string);
 }
 
 }  // namespace
 
 class SystemInfoHandlerGpuObserver : public content::GpuDataManagerObserver {
  public:
   SystemInfoHandlerGpuObserver(base::WeakPtr<SystemInfoHandler> handler,
+                               int session_id,
                                DevToolsCommandId command_id)
       : handler_(handler),
+        session_id_(session_id),
         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 {
     UnregisterAndSendResponse();
   }
 
   void UnregisterAndSendResponse() {
     GpuDataManager::GetInstance()->RemoveObserver(this);
     if (handler_.get()) {
       if (handler_->RemoveActiveObserverId(observer_id_)) {
-        handler_->SendGetInfoResponse(command_id_);
+        handler_->SendGetInfoResponse(session_id_, command_id_);
       }
     }
     delete this;
   }
 
   int GetObserverId() {
     return observer_id_;
   }
 
  private:
   base::WeakPtr<SystemInfoHandler> handler_;
+  int session_id_;
   DevToolsCommandId command_id_;
   int observer_id_;
 
   static int next_observer_id_;
 };
 
 int SystemInfoHandlerGpuObserver::next_observer_id_ = 0;
 
 SystemInfoHandler::SystemInfoHandler()
     : weak_factory_(this) {
 }
 
 SystemInfoHandler::~SystemInfoHandler() {
 }
 
 void SystemInfoHandler::SetClient(scoped_ptr<Client> client) {
   client_.swap(client);
 }
 
-Response SystemInfoHandler::GetInfo(DevToolsCommandId command_id) {
+Response SystemInfoHandler::GetInfo(int session_id,
+                                    DevToolsCommandId command_id) {
   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,
+        BrowserThread::UI, FROM_HERE,
         base::Bind(&SystemInfoHandler::SendGetInfoResponse,
-                   weak_factory_.GetWeakPtr(),
-                   command_id));
+                   weak_factory_.GetWeakPtr(), session_id, 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);
+        weak_factory_.GetWeakPtr(), session_id, command_id);
     BrowserThread::PostDelayedTask(
-        BrowserThread::UI,
-        FROM_HERE,
+        BrowserThread::UI, FROM_HERE,
         base::Bind(&SystemInfoHandler::ObserverWatchdogCallback,
-                   weak_factory_.GetWeakPtr(),
-                   observer->GetObserverId(),
-                   command_id),
+                   weak_factory_.GetWeakPtr(), observer->GetObserverId(),
+                   session_id, 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) {
+void SystemInfoHandler::SendGetInfoResponse(int session_id,
+                                            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));
+      session_id, 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,
+                                                 int session_id,
                                                  DevToolsCommandId command_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (RemoveActiveObserverId(observer_id)) {
-    SendGetInfoResponse(command_id);
+    SendGetInfoResponse(session_id, 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