Standardize usage of virtual/override/final in content/browser/

content/browser/resolve_proxy_msg_helper_unittest.cc

 // Copyright (c) 2011 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/resolve_proxy_msg_helper.h"
 
 #include "content/browser/browser_thread_impl.h"
 #include "content/common/view_messages.h"
 #include "ipc/ipc_test_sink.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/mock_proxy_resolver.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 // This ProxyConfigService always returns "http://pac" as the PAC url to use.
 class MockProxyConfigService : public net::ProxyConfigService {
  public:
-  virtual void AddObserver(Observer* observer) override {}
-  virtual void RemoveObserver(Observer* observer) override {}
-  virtual ConfigAvailability GetLatestProxyConfig(
-      net::ProxyConfig* results) override {
+  void AddObserver(Observer* observer) override {}
+  void RemoveObserver(Observer* observer) override {}
+  ConfigAvailability GetLatestProxyConfig(net::ProxyConfig* results) override {
     *results = net::ProxyConfig::CreateFromCustomPacURL(GURL("http://pac"));
     return CONFIG_VALID;
   }
 };
 
 class TestResolveProxyMsgHelper : public ResolveProxyMsgHelper {
  public:
   TestResolveProxyMsgHelper(
       net::ProxyService* proxy_service,
       IPC::Listener* listener)
       : ResolveProxyMsgHelper(proxy_service),
         listener_(listener) {}
-  virtual bool Send(IPC::Message* message) override {
+  bool Send(IPC::Message* message) override {
     listener_->OnMessageReceived(*message);
     delete message;
     return true;
   }
 
  protected:
-  virtual ~TestResolveProxyMsgHelper() {}
+  ~TestResolveProxyMsgHelper() override {}
 
   IPC::Listener* listener_;
 };
 
 class ResolveProxyMsgHelperTest : public testing::Test, public IPC::Listener {
  public:
   struct PendingResult {
     PendingResult(bool result,
                   const std::string& proxy_list)
         : result(result), proxy_list(proxy_list) {
@@ skipping 25 matching lines @@
     ViewHostMsg_ResolveProxy message(GURL(), &temp_bool, &temp_string);
     return IPC::SyncMessage::GenerateReply(&message);
   }
 
   net::MockAsyncProxyResolver* resolver_;
   scoped_ptr<net::ProxyService> service_;
   scoped_refptr<ResolveProxyMsgHelper> helper_;
   scoped_ptr<PendingResult> pending_result_;
 
  private:
-  virtual bool OnMessageReceived(const IPC::Message& msg) override {
+  bool OnMessageReceived(const IPC::Message& msg) override {
     TupleTypes<ViewHostMsg_ResolveProxy::ReplyParam>::ValueTuple reply_data;
     EXPECT_TRUE(ViewHostMsg_ResolveProxy::ReadReplyParam(&msg, &reply_data));
     DCHECK(!pending_result_.get());
     pending_result_.reset(new PendingResult(reply_data.a, reply_data.b));
     test_sink_.ClearMessages();
     return true;
   }
 
   base::MessageLoopForIO message_loop_;
   BrowserThreadImpl io_thread_;
@@ skipping 146 matching lines @@
 
   EXPECT_EQ(0u, resolver_->pending_requests().size());
 
   EXPECT_TRUE(pending_result() == NULL);
 
   // It should also be the case that msg1, msg2, msg3 were deleted by the
   // cancellation. (Else will show up as a leak in Valgrind).
 }
 
 }  // namespace content