[ChromeDriver] Add support for attaching multiple DevToolsEventListeners to a DevToolsClient.

chrome/test/chromedriver/devtools_client_impl.cc

 // Copyright (c) 2012 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/test/chromedriver/devtools_client_impl.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/devtools_event_listener.h"
 #include "chrome/test/chromedriver/net/sync_websocket.h"
 #include "chrome/test/chromedriver/net/url_request_context_getter.h"
 #include "chrome/test/chromedriver/status.h"
 
 namespace internal {
 
 InspectorEvent::InspectorEvent() {}
 
 InspectorEvent::~InspectorEvent() {}
 
 InspectorCommandResponse::InspectorCommandResponse() {}
 
 InspectorCommandResponse::~InspectorCommandResponse() {}
 
 }  // namespace internal
 
 DevToolsClientImpl::DevToolsClientImpl(
     const SyncWebSocketFactory& factory,
-    const std::string& url,
-    DevToolsEventListener* listener)
+    const std::string& url)
     : socket_(factory.Run().Pass()),
       url_(url),
-      listener_(listener),
       parser_func_(base::Bind(&internal::ParseInspectorMessage)),
       connected_(false),
       next_id_(1) {}
 
 DevToolsClientImpl::DevToolsClientImpl(
     const SyncWebSocketFactory& factory,
     const std::string& url,
-    DevToolsEventListener* listener,
     const ParserFunc& parser_func)
     : socket_(factory.Run().Pass()),
       url_(url),
-      listener_(listener),
       parser_func_(parser_func),
       connected_(false),
       next_id_(1) {}
 
 DevToolsClientImpl::~DevToolsClientImpl() {}
 
 Status DevToolsClientImpl::SendCommand(
     const std::string& method,
     const base::DictionaryValue& params) {
   scoped_ptr<base::DictionaryValue> result;
   return SendCommandInternal(method, params, &result);
 }
 
 Status DevToolsClientImpl::SendCommandAndGetResult(
     const std::string& method,
     const base::DictionaryValue& params,
     scoped_ptr<base::DictionaryValue>* result) {
   scoped_ptr<base::DictionaryValue> intermediate_result;
   Status status = SendCommandInternal(method, params, &intermediate_result);
   if (status.IsError())
     return status;
   if (!intermediate_result)
     return Status(kUnknownError, "inspector response missing result");
   result->reset(intermediate_result.release());
   return Status(kOk);
 }
 
+void DevToolsClientImpl::AddListener(DevToolsEventListener* listener) {
+  DCHECK(listener);
+  listeners_.push_back(listener);
+}
+
 Status DevToolsClientImpl::SendCommandInternal(
     const std::string& method,
     const base::DictionaryValue& params,
     scoped_ptr<base::DictionaryValue>* result) {
   if (!connected_) {
     if (!socket_->Connect(url_))
       return Status(kUnknownError, "unable to connect to renderer");
     connected_ = true;
   }
 
@@ skipping 11 matching lines @@
   while (true) {
     std::string message;
     if (!socket_->ReceiveNextMessage(&message))
       return Status(kUnknownError, "unable to receive message from renderer");
     internal::InspectorMessageType type;
     internal::InspectorEvent event;
     internal::InspectorCommandResponse response;
     if (!parser_func_.Run(message, command_id, &type, &event, &response))
       return Status(kUnknownError, "bad inspector message: " + message);
     if (type == internal::kEventMessageType) {
-      if (listener_)
-        listener_->OnEvent(event.method, *event.params);
+      NotifyEventListeners(event.method, *event.params);
     } else {
       if (response.id != command_id) {
         return Status(kUnknownError,
                       "received response for unknown command ID");
       }
       if (response.result) {
         result->reset(response.result.release());
         return Status(kOk);
       }
       return Status(kUnknownError, "inspector error: " + response.error);
     }
   }
 }
 
+void DevToolsClientImpl::NotifyEventListeners(
+    const std::string& method,
+    const base::DictionaryValue& params) {
+  for (std::list<DevToolsEventListener*>::iterator iter = listeners_.begin();
+       iter != listeners_.end(); ++iter) {
+    (*iter)->OnEvent(method, params);
+  }
+}
+
 namespace internal {
 
 bool ParseInspectorMessage(
     const std::string& message,
     int expected_id,
     InspectorMessageType* type,
     InspectorEvent* event,
     InspectorCommandResponse* command_response) {
   scoped_ptr<base::Value> message_value(base::JSONReader::Read(message));
   base::DictionaryValue* message_dict;
@@ skipping 27 matching lines @@
     if (unscoped_result)
       command_response->result.reset(unscoped_result->DeepCopy());
     else
       base::JSONWriter::Write(unscoped_error, &command_response->error);
     return true;
   }
   return false;
 }
 
 }  // namespace internal