[ChromeDriver] Added CommandListener interface

chrome/test/chromedriver/commands_unittest.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 <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
@@ skipping 528 matching lines @@
   scoped_ptr<base::Value> result;
   ASSERT_EQ(
       kStaleElementReference,
       ExecuteFindChildElement(
           1, &session, &web_view, element_id, params, &result).code());
   ASSERT_EQ(
       kStaleElementReference,
       ExecuteFindChildElements(
           1, &session, &web_view, element_id, params, &result).code());
 }
+
+namespace {
+
+class MockCommandListener : public CommandListener {
+ public:
+  MockCommandListener() : called_(false) {}
+  virtual ~MockCommandListener() {}
+
+  virtual Status OnCommand(const std::string& command_name) OVERRIDE {
+    called_ = true;
+    EXPECT_STREQ("cmd", command_name.c_str());
+    return Status(kOk);
+  }
+
+  void VerifyCalled() {
+    EXPECT_TRUE(called_);
+  }
+
+  void VerifyNotCalled() {
+    EXPECT_FALSE(called_);
+  }
+
+ private:
+  bool called_;
+};
+
+Status ExecuteAddListenerToSession(
+    MockCommandListener* listener,
+    Session* session,
+    const base::DictionaryValue& params,
+    scoped_ptr<base::Value>* return_value) {
+  session->AddListener(listener);
+  listener->VerifyNotCalled();
+  return Status(kOk);
+}
+
+Status ExecuteTestListener(
+    Session* session,
+    const base::DictionaryValue& params,
+    scoped_ptr<base::Value>* return_value) {
+  session->quit = true;
+  return Status(kOk);
+}
+
+void VerifyListenerNotNotifiedAfterCommandRun(
+    MockCommandListener* listener,
+    base::RunLoop* run_loop,
+    const Status& status,
+    scoped_ptr<base::Value> value,
+    const std::string& session_id) {
+  ASSERT_EQ(kOk, status.code());
+  listener->VerifyNotCalled();
+  run_loop->Quit();
+}
+
+
+void VerifyListenerNotifiedBeforeCommandRun(
+    MockCommandListener* listener,
+    base::RunLoop* run_loop,
+    const Status& status,
+    scoped_ptr<base::Value> value,
+    const std::string& session_id) {
+  ASSERT_EQ(kOk, status.code());
+  listener->VerifyCalled();
+  run_loop->Quit();
+}
+
+}  // namespace
+
+TEST(CommandsTest, SessionNotifiedOfCommand) {
+  SessionThreadMap map;
+  linked_ptr<base::Thread> thread(new base::Thread("1"));
+  ASSERT_TRUE(thread->Start());
+  std::string id("id");
+  thread->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&internal::CreateSessionOnSessionThreadForTesting, id));
+  map[id] = thread;
+
+  base::DictionaryValue params;
+  MockCommandListener* listener = new MockCommandListener();

[stgao, 2014/06/15 23:54:40]

Memory leak here.
You could use a scoped_ptr, just like linked_ptr above.

[johnmoore, 2014/06/16 20:49:18]

(See reply to other memory leak concern)

+  SessionCommand cmd = base::Bind(
+      &ExecuteAddListenerToSession, listener);
+
+  base::MessageLoop loop;
+  base::RunLoop run_loop_addlistener;
+
+  // Listeners are notified immediately before commands are run.
+  // Here, the command adds the listener to the session, so the listener
+  // should not be notified since it will not have been added yet.
+  ExecuteSessionCommand(
+      &map,
+      "cmd",
+      cmd,
+      false,
+      params,
+      id,
+      base::Bind(&VerifyListenerNotNotifiedAfterCommandRun, listener,
+                 &run_loop_addlistener));
+
+  run_loop_addlistener.Run();
+
+  base::RunLoop run_loop_testlistener;
+  cmd = base::Bind(
+        &ExecuteTestListener);
+
+  // The listener has been added to the session and should be notified of
+  // the ExecuteTestListener command.
+  ExecuteSessionCommand(
+      &map,
+      "cmd",
+      cmd,
+      false,
+      params,
+      id,
+      base::Bind(&VerifyListenerNotifiedBeforeCommandRun, listener,
+                 &run_loop_testlistener));
+
+  run_loop_testlistener.Run();
+}