Replace FINAL and OVERRIDE with their C++11 counterparts in chrome/test

chrome/test/chromedriver/chrome/devtools_client_impl_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 <list>
 #include <string>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
@@ skipping 13 matching lines @@
 
 Status CloserFunc() {
   return Status(kOk);
 }
 
 class MockSyncWebSocket : public SyncWebSocket {
  public:
   MockSyncWebSocket() : connected_(false), id_(-1), queued_messages_(1) {}
   virtual ~MockSyncWebSocket() {}
 
-  virtual bool IsConnected() OVERRIDE {
+  virtual bool IsConnected() override {
     return connected_;
   }
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     EXPECT_STREQ("http://url/", url.possibly_invalid_spec().c_str());
     connected_ = true;
     return true;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     EXPECT_TRUE(connected_);
     scoped_ptr<base::Value> value(base::JSONReader::Read(message));
     base::DictionaryValue* dict = NULL;
     EXPECT_TRUE(value->GetAsDictionary(&dict));
     if (!dict)
       return false;
     EXPECT_TRUE(dict->GetInteger("id", &id_));
     std::string method;
     EXPECT_TRUE(dict->GetString("method", &method));
     EXPECT_STREQ("method", method.c_str());
     base::DictionaryValue* params = NULL;
     EXPECT_TRUE(dict->GetDictionary("params", &params));
     if (!params)
       return false;
     int param = -1;
     EXPECT_TRUE(params->GetInteger("param", &param));
     EXPECT_EQ(1, param);
     return true;
   }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     if (timeout <= base::TimeDelta())
       return SyncWebSocket::kTimeout;
     base::DictionaryValue response;
     response.SetInteger("id", id_);
     base::DictionaryValue result;
     result.SetInteger("param", 1);
     response.Set("result", result.DeepCopy());
     base::JSONWriter::Write(&response, message);
     --queued_messages_;
     return SyncWebSocket::kOk;
   }
 
-  virtual bool HasNextMessage() OVERRIDE {
+  virtual bool HasNextMessage() override {
     return queued_messages_ > 0;
   }
 
  protected:
   bool connected_;
   int id_;
   int queued_messages_;
 };
 
 template <typename T>
@@ skipping 37 matching lines @@
   ASSERT_STREQ("{\"param\":1}", json.c_str());
 }
 
 namespace {
 
 class MockSyncWebSocket2 : public SyncWebSocket {
  public:
   MockSyncWebSocket2() {}
   virtual ~MockSyncWebSocket2() {}
 
-  virtual bool IsConnected() OVERRIDE {
+  virtual bool IsConnected() override {
     return false;
   }
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     return false;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     EXPECT_TRUE(false);
     return false;
   }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     EXPECT_TRUE(false);
     return SyncWebSocket::kDisconnected;
   }
 
-  virtual bool HasNextMessage() OVERRIDE {
+  virtual bool HasNextMessage() override {
     return true;
   }
 };
 
 }  // namespace
 
 TEST_F(DevToolsClientImplTest, ConnectIfNecessaryConnectFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket2>);
   DevToolsClientImpl client(factory, "http://url", "id",
                             base::Bind(&CloserFunc));
   ASSERT_EQ(kDisconnected, client.ConnectIfNecessary().code());
 }
 
 namespace {
 
 class MockSyncWebSocket3 : public SyncWebSocket {
  public:
   MockSyncWebSocket3() : connected_(false) {}
   virtual ~MockSyncWebSocket3() {}
 
-  virtual bool IsConnected() OVERRIDE {
+  virtual bool IsConnected() override {
     return connected_;
   }
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     connected_ = true;
     return true;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     return false;
   }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     EXPECT_TRUE(false);
     return SyncWebSocket::kDisconnected;
   }
 
-  virtual bool HasNextMessage() OVERRIDE {
+  virtual bool HasNextMessage() override {
     return true;
   }
 
  private:
   bool connected_;
 };
 
 }  // namespace
 
 TEST_F(DevToolsClientImplTest, SendCommandSendFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket3>);
   DevToolsClientImpl client(factory, "http://url", "id",
                             base::Bind(&CloserFunc));
   ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 namespace {
 
 class MockSyncWebSocket4 : public SyncWebSocket {
  public:
   MockSyncWebSocket4() : connected_(false) {}
   virtual ~MockSyncWebSocket4() {}
 
-  virtual bool IsConnected() OVERRIDE {
+  virtual bool IsConnected() override {
     return connected_;
   }
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     connected_ = true;
     return true;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     return true;
   }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     return SyncWebSocket::kDisconnected;
   }
 
-  virtual bool HasNextMessage() OVERRIDE {
+  virtual bool HasNextMessage() override {
     return true;
   }
 
  private:
   bool connected_;
 };
 
 }  // namespace
 
 TEST_F(DevToolsClientImplTest, SendCommandReceiveNextMessageFails) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket4>);
   DevToolsClientImpl client(factory, "http://url", "id",
                             base::Bind(&CloserFunc));
   ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   base::DictionaryValue params;
   ASSERT_TRUE(client.SendCommand("method", params).IsError());
 }
 
 namespace {
 
 class FakeSyncWebSocket : public SyncWebSocket {
  public:
   FakeSyncWebSocket() : connected_(false) {}
   virtual ~FakeSyncWebSocket() {}
 
-  virtual bool IsConnected() OVERRIDE {
+  virtual bool IsConnected() override {
     return connected_;
   }
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     EXPECT_FALSE(connected_);
     connected_ = true;
     return true;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     return true;
   }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     return SyncWebSocket::kOk;
   }
 
-  virtual bool HasNextMessage() OVERRIDE {
+  virtual bool HasNextMessage() override {
     return true;
   }
 
  private:
   bool connected_;
 };
 
 bool ReturnCommand(
     const std::string& message,
     int expected_id,
@@ skipping 42 matching lines @@
   return true;
 }
 
 class MockListener : public DevToolsEventListener {
  public:
   MockListener() : called_(false) {}
   virtual ~MockListener() {
     EXPECT_TRUE(called_);
   }
 
-  virtual Status OnConnected(DevToolsClient* client) OVERRIDE {
+  virtual Status OnConnected(DevToolsClient* client) override {
     return Status(kOk);
   }
 
   virtual Status OnEvent(DevToolsClient* client,
                          const std::string& method,
-                         const base::DictionaryValue& params) OVERRIDE {
+                         const base::DictionaryValue& params) override {
     called_ = true;
     EXPECT_STREQ("method", method.c_str());
     EXPECT_TRUE(params.HasKey("key"));
     return Status(kOk);
   }
 
  private:
   bool called_;
 };
 
@@ skipping 322 matching lines @@
         on_event_called_(false) {
     client_->AddListener(this);
   }
   virtual ~OnConnectedListener() {}
 
   void VerifyCalled() {
     EXPECT_TRUE(on_connected_called_);
     EXPECT_TRUE(on_event_called_);
   }
 
-  virtual Status OnConnected(DevToolsClient* client) OVERRIDE {
+  virtual Status OnConnected(DevToolsClient* client) override {
     EXPECT_EQ(client_, client);
     EXPECT_STREQ("onconnected-id", client->GetId().c_str());
     EXPECT_FALSE(on_connected_called_);
     EXPECT_FALSE(on_event_called_);
     on_connected_called_ = true;
     base::DictionaryValue params;
     return client_->SendCommand(method_, params);
   }
 
   virtual Status OnEvent(DevToolsClient* client,
                          const std::string& method,
-                         const base::DictionaryValue& params) OVERRIDE {
+                         const base::DictionaryValue& params) override {
     EXPECT_EQ(client_, client);
     EXPECT_STREQ("onconnected-id", client->GetId().c_str());
     EXPECT_TRUE(on_connected_called_);
     on_event_called_ = true;
     return Status(kOk);
   }
 
  private:
   std::string method_;
   DevToolsClient* client_;
   bool on_connected_called_;
   bool on_event_called_;
 };
 
 class OnConnectedSyncWebSocket : public SyncWebSocket {
  public:
   OnConnectedSyncWebSocket() : connected_(false) {}
   virtual ~OnConnectedSyncWebSocket() {}
 
-  virtual bool IsConnected() OVERRIDE {
+  virtual bool IsConnected() override {
     return connected_;
   }
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     connected_ = true;
     return true;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     EXPECT_TRUE(connected_);
     scoped_ptr<base::Value> value(base::JSONReader::Read(message));
     base::DictionaryValue* dict = NULL;
     EXPECT_TRUE(value->GetAsDictionary(&dict));
     if (!dict)
       return false;
     int id;
     EXPECT_TRUE(dict->GetInteger("id", &id));
     std::string method;
     EXPECT_TRUE(dict->GetString("method", &method));
@@ skipping 11 matching lines @@
     event.Set("params", new base::DictionaryValue());
     std::string json_event;
     base::JSONWriter::Write(&event, &json_event);
     queued_response_.push_back(json_event);
 
     return true;
   }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     if (queued_response_.empty())
       return SyncWebSocket::kDisconnected;
     *message = queued_response_.front();
     queued_response_.pop_front();
     return SyncWebSocket::kOk;
   }
 
-  virtual bool HasNextMessage() OVERRIDE {
+  virtual bool HasNextMessage() override {
     return !queued_response_.empty();
   }
 
  private:
   bool connected_;
   std::list<std::string> queued_response_;
 };
 
 }  // namespace
 
@@ skipping 28 matching lines @@
   listener3.VerifyCalled();
 }
 
 namespace {
 
 class MockSyncWebSocket5 : public SyncWebSocket {
  public:
   MockSyncWebSocket5() : request_no_(0) {}
   virtual ~MockSyncWebSocket5() {}
 
-  virtual bool IsConnected() OVERRIDE {
+  virtual bool IsConnected() override {
     return true;
   }
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     return true;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     return true;
   }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     if (request_no_ == 0) {
       *message = "{\"method\": \"m\", \"params\": {}}";
     } else {
       *message = base::StringPrintf(
           "{\"result\": {}, \"id\": %d}", request_no_);
     }
     request_no_++;
     return SyncWebSocket::kOk;
   }
 
-  virtual bool HasNextMessage() OVERRIDE {
+  virtual bool HasNextMessage() override {
     return false;
   }
 
  private:
   int request_no_;
 };
 
 class OtherEventListener : public DevToolsEventListener {
  public:
   OtherEventListener() : received_event_(false) {}
   virtual ~OtherEventListener() {}
 
-  virtual Status OnConnected(DevToolsClient* client) OVERRIDE {
+  virtual Status OnConnected(DevToolsClient* client) override {
     return Status(kOk);
   }
   virtual Status OnEvent(DevToolsClient* client,
                          const std::string& method,
-                         const base::DictionaryValue& params) OVERRIDE {
+                         const base::DictionaryValue& params) override {
     received_event_ = true;
     return Status(kOk);
   }
 
   bool received_event_;
 };
 
 class OnEventListener : public DevToolsEventListener {
  public:
   OnEventListener(DevToolsClient* client,
                   OtherEventListener* other_listener)
       : client_(client),
         other_listener_(other_listener) {}
   virtual ~OnEventListener() {}
 
-  virtual Status OnConnected(DevToolsClient* client) OVERRIDE {
+  virtual Status OnConnected(DevToolsClient* client) override {
     EXPECT_EQ(client_, client);
     return Status(kOk);
   }
 
   virtual Status OnEvent(DevToolsClient* client,
                          const std::string& method,
-                         const base::DictionaryValue& params) OVERRIDE {
+                         const base::DictionaryValue& params) override {
     EXPECT_EQ(client_, client);
     client_->SendCommand("method", params);
     EXPECT_TRUE(other_listener_->received_event_);
     return Status(kOk);
   }
 
  private:
   DevToolsClient* client_;
   OtherEventListener* other_listener_;
 };
@@ skipping 13 matching lines @@
   EXPECT_EQ(kOk, client.SendCommand("method", params).code());
 }
 
 namespace {
 
 class DisconnectedSyncWebSocket : public MockSyncWebSocket {
  public:
   DisconnectedSyncWebSocket() : connection_count_(0), command_count_(0) {}
   virtual ~DisconnectedSyncWebSocket() {}
 
-  virtual bool Connect(const GURL& url) OVERRIDE {
+  virtual bool Connect(const GURL& url) override {
     connection_count_++;
     connected_ = connection_count_ != 2;
     return connected_;
   }
 
-  virtual bool Send(const std::string& message) OVERRIDE {
+  virtual bool Send(const std::string& message) override {
     command_count_++;
     if (command_count_ == 1) {
       connected_ = false;
       return false;
     }
     return MockSyncWebSocket::Send(message);
   }
 
  private:
   int connection_count_;
@@ skipping 33 matching lines @@
 }
 
 namespace {
 
 class MockSyncWebSocket6 : public SyncWebSocket {
  public:
   explicit MockSyncWebSocket6(std::list<std::string>* messages)
       : messages_(messages) {}
   virtual ~MockSyncWebSocket6() {}
 
-  virtual bool IsConnected() OVERRIDE { return true; }
+  virtual bool IsConnected() override { return true; }
 
-  virtual bool Connect(const GURL& url) OVERRIDE { return true; }
+  virtual bool Connect(const GURL& url) override { return true; }
 
-  virtual bool Send(const std::string& message) OVERRIDE { return true; }
+  virtual bool Send(const std::string& message) override { return true; }
 
   virtual SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
-      const base::TimeDelta& timeout) OVERRIDE {
+      const base::TimeDelta& timeout) override {
     if (messages_->empty())
       return SyncWebSocket::kDisconnected;
     *message = messages_->front();
     messages_->pop_front();
     return SyncWebSocket::kOk;
   }
 
-  virtual bool HasNextMessage() OVERRIDE { return messages_->size(); }
+  virtual bool HasNextMessage() override { return messages_->size(); }
 
  private:
   std::list<std::string>* messages_;
 };
 
 class MockDevToolsEventListener : public DevToolsEventListener {
  public:
   MockDevToolsEventListener() : id_(1) {}
   virtual ~MockDevToolsEventListener() {}
 
-  virtual Status OnConnected(DevToolsClient* client) OVERRIDE {
+  virtual Status OnConnected(DevToolsClient* client) override {
     return Status(kOk);
   }
 
   virtual Status OnEvent(DevToolsClient* client,
                          const std::string& method,
-                         const base::DictionaryValue& params) OVERRIDE {
+                         const base::DictionaryValue& params) override {
     id_++;
     Status status = client->SendCommand("hello", params);
     id_--;
     if (id_ == 3) {
       EXPECT_EQ(kUnexpectedAlertOpen, status.code());
     } else {
       EXPECT_EQ(kOk, status.code());
     }
     return Status(kOk);
   }
@@ skipping 63 matching lines @@
 
 namespace {
 
 class MockCommandListener : public DevToolsEventListener {
  public:
   MockCommandListener() {}
   virtual ~MockCommandListener() {}
 
   virtual Status OnEvent(DevToolsClient* client,
                          const std::string& method,
-                         const base::DictionaryValue& params) OVERRIDE {
+                         const base::DictionaryValue& params) override {
     msgs_.push_back(method);
     return Status(kOk);
   }
 
   virtual Status OnCommandSuccess(DevToolsClient* client,
-                                  const std::string& method) OVERRIDE {
+                                  const std::string& method) override {
     msgs_.push_back(method);
     if (!callback_.is_null())
       callback_.Run(client);
     return Status(kOk);
   }
 
   base::Callback<void(DevToolsClient*)> callback_;
   std::list<std::string> msgs_;
 };
 
@@ skipping 14 matching lines @@
   client.AddListener(&listener1);
   client.AddListener(&listener2);
   msgs.push_back("{\"id\": 1, \"result\": {}}");
   msgs.push_back("{\"method\": \"event\", \"params\": {}}");
   base::DictionaryValue params;
   ASSERT_EQ(kOk, client.SendCommand("cmd", params).code());
   ASSERT_EQ(2u, listener2.msgs_.size());
   ASSERT_EQ("cmd", listener2.msgs_.front());
   ASSERT_EQ("event", listener2.msgs_.back());
 }