[ChromeDriver] Send DOM.getDocument after each DOM.documentUpdated.

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"
@@ skipping 26 matching lines @@
 DevToolsClientImpl::DevToolsClientImpl(
     const SyncWebSocketFactory& factory,
     const std::string& url,
     const ParserFunc& parser_func)
     : socket_(factory.Run().Pass()),
       url_(url),
       parser_func_(parser_func),
       connected_(false),
       next_id_(1) {}
 
-DevToolsClientImpl::~DevToolsClientImpl() {}
+DevToolsClientImpl::~DevToolsClientImpl() {
+  for (ResponseMap::iterator iter = cmd_response_map_.begin();
+       iter != cmd_response_map_.end(); ++iter) {
+    LOG(WARNING) << "Finished with no response for command " << iter->first;
+    delete iter->second;
+  }
+}
 
 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,
@@ skipping 55 matching lines @@
 
   return ReceiveCommandResponse(command_id, result);
 }
 
 Status DevToolsClientImpl::ReceiveCommandResponse(
     int command_id,
     scoped_ptr<base::DictionaryValue>* result) {
   internal::InspectorMessageType type;
   internal::InspectorEvent event;
   internal::InspectorCommandResponse response;
-  while (true) {
+  cmd_response_map_[command_id] = NULL;

[kkania, 2013/01/30 22:36:05]

what's this about?

[craigdh, 2013/01/30 23:05:21]

The overarching idea is that we support overlapping/nested commands. The logic
goes like this:

Before waiting for a response the map[command_id] is set to NULL. Then we
receive messages until the map[command_id] contains a response.

If we receive a response with a command_id not in the map then we have received
a response for an unknown command ID and it's an error. Otherwise store the
result in the map.

+  while (cmd_response_map_[command_id] == NULL) {
     Status status = ReceiveNextMessage(command_id, &type, &event, &response);
     if (status.IsError()) {
       return status;
     } else if (type == internal::kCommandResponseMessageType) {
-      if (response.id != command_id) {
+      if (cmd_response_map_.count(response.id) == 0) {
         return Status(kUnknownError,
                       "received response for unknown command ID");
+      } else if (response.result) {
+        cmd_response_map_[response.id] = response.result.release();
+      } else {
+        return Status(kUnknownError, "inspector error: " + response.error);
       }
-      if (response.result) {
-        result->reset(response.result.release());
-        return Status(kOk);
-      }
-      return Status(kUnknownError, "inspector error: " + response.error);
     }
   }
+  result->reset(cmd_response_map_[command_id]);
+  cmd_response_map_.erase(command_id);
+  return Status(kOk);
 }
 
 Status DevToolsClientImpl::ReceiveNextMessage(
     int expected_id,
     internal::InspectorMessageType* type,
     internal::InspectorEvent* event,
     internal::InspectorCommandResponse* response) {
   std::string message;
   if (!socket_->ReceiveNextMessage(&message)) {
     connected_ = false;
@@ skipping 61 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