Standardize usage of virtual/override/final in net/

net/proxy/multi_threaded_proxy_resolver_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 "net/proxy/multi_threaded_proxy_resolver.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 18 matching lines @@
 // conjunction with MultiThreadedProxyResolver.
 //       - returns a single-item proxy list with the query's host.
 class MockProxyResolver : public ProxyResolver {
  public:
   MockProxyResolver()
       : ProxyResolver(true /*expects_pac_bytes*/),
         wrong_loop_(base::MessageLoop::current()),
         request_count_(0) {}
 
   // ProxyResolver implementation.
-  virtual int GetProxyForURL(const GURL& query_url,
-                             ProxyInfo* results,
-                             const CompletionCallback& callback,
-                             RequestHandle* request,
-                             const BoundNetLog& net_log) override {
+  int GetProxyForURL(const GURL& query_url,
+                     ProxyInfo* results,
+                     const CompletionCallback& callback,
+                     RequestHandle* request,
+                     const BoundNetLog& net_log) override {
     if (resolve_latency_ != base::TimeDelta())
       base::PlatformThread::Sleep(resolve_latency_);
 
     CheckIsOnWorkerThread();
 
     EXPECT_TRUE(callback.is_null());
     EXPECT_TRUE(request == NULL);
 
     // Write something into |net_log| (doesn't really have any meaning.)
     net_log.BeginEvent(NetLog::TYPE_PAC_JAVASCRIPT_ALERT);
 
     results->UseNamedProxy(query_url.host());
 
     // Return a success code which represents the request's order.
     return request_count_++;
   }
 
-  virtual void CancelRequest(RequestHandle request) override {
-    NOTREACHED();
-  }
+  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
 
-  virtual LoadState GetLoadState(RequestHandle request) const override {
+  LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() override {
-    NOTREACHED();
-  }
+  void CancelSetPacScript() override { NOTREACHED(); }
 
-  virtual int SetPacScript(
-      const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const CompletionCallback& callback) override {
+  int SetPacScript(const scoped_refptr<ProxyResolverScriptData>& script_data,
+                   const CompletionCallback& callback) override {
     CheckIsOnWorkerThread();
     last_script_data_ = script_data;
     return OK;
   }
 
   int request_count() const { return request_count_; }
 
   const ProxyResolverScriptData* last_script_data() const {
     return last_script_data_.get();
   }
@@ skipping 39 matching lines @@
   void Unblock() {
     should_block_ = false;
     blocked_.Reset();
     unblocked_.Signal();
   }
 
   void WaitUntilBlocked() {
     blocked_.Wait();
   }
 
-  virtual int GetProxyForURL(const GURL& query_url,
-                             ProxyInfo* results,
-                             const CompletionCallback& callback,
-                             RequestHandle* request,
-                             const BoundNetLog& net_log) override {
+  int GetProxyForURL(const GURL& query_url,
+                     ProxyInfo* results,
+                     const CompletionCallback& callback,
+                     RequestHandle* request,
+                     const BoundNetLog& net_log) override {
     if (should_block_) {
       blocked_.Signal();
       unblocked_.Wait();
     }
 
     return MockProxyResolver::GetProxyForURL(
         query_url, results, callback, request, net_log);
   }
 
  private:
   bool should_block_;
   base::WaitableEvent unblocked_;
   base::WaitableEvent blocked_;
 };
 
 // ForwardingProxyResolver forwards all requests to |impl|.
 class ForwardingProxyResolver : public ProxyResolver {
  public:
   explicit ForwardingProxyResolver(ProxyResolver* impl)
       : ProxyResolver(impl->expects_pac_bytes()),
         impl_(impl) {}
 
-  virtual int GetProxyForURL(const GURL& query_url,
-                             ProxyInfo* results,
-                             const CompletionCallback& callback,
-                             RequestHandle* request,
-                             const BoundNetLog& net_log) override {
+  int GetProxyForURL(const GURL& query_url,
+                     ProxyInfo* results,
+                     const CompletionCallback& callback,
+                     RequestHandle* request,
+                     const BoundNetLog& net_log) override {
     return impl_->GetProxyForURL(
         query_url, results, callback, request, net_log);
   }
 
-  virtual void CancelRequest(RequestHandle request) override {
+  void CancelRequest(RequestHandle request) override {
     impl_->CancelRequest(request);
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const override {
+  LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() override {
-    impl_->CancelSetPacScript();
-  }
+  void CancelSetPacScript() override { impl_->CancelSetPacScript(); }
 
-  virtual int SetPacScript(
-      const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const CompletionCallback& callback) override {
+  int SetPacScript(const scoped_refptr<ProxyResolverScriptData>& script_data,
+                   const CompletionCallback& callback) override {
     return impl_->SetPacScript(script_data, callback);
   }
 
  private:
   ProxyResolver* impl_;
 };
 
 // This factory returns ProxyResolvers that forward all requests to
 // |resolver|.
 class ForwardingProxyResolverFactory : public ProxyResolverFactory {
  public:
   explicit ForwardingProxyResolverFactory(ProxyResolver* resolver)
       : ProxyResolverFactory(resolver->expects_pac_bytes()),
         resolver_(resolver) {}
 
-  virtual ProxyResolver* CreateProxyResolver() override {
+  ProxyResolver* CreateProxyResolver() override {
     return new ForwardingProxyResolver(resolver_);
   }
 
  private:
   ProxyResolver* resolver_;
 };
 
 // This factory returns new instances of BlockableProxyResolver.
 class BlockableProxyResolverFactory : public ProxyResolverFactory {
  public:
   BlockableProxyResolverFactory() : ProxyResolverFactory(true) {}
 
-  virtual ~BlockableProxyResolverFactory() {
-    STLDeleteElements(&resolvers_);
-  }
+  ~BlockableProxyResolverFactory() override { STLDeleteElements(&resolvers_); }
 
-  virtual ProxyResolver* CreateProxyResolver() override {
+  ProxyResolver* CreateProxyResolver() override {
     BlockableProxyResolver* resolver = new BlockableProxyResolver;
     resolvers_.push_back(resolver);
     return new ForwardingProxyResolver(resolver);
   }
 
   std::vector<BlockableProxyResolver*> resolvers() {
     return resolvers_;
   }
 
  private:
@@ skipping 523 matching lines @@
   // All in all, the first thread should have seen just 1 request. And the
   // second thread 3 requests.
   ASSERT_EQ(2u, factory->resolvers().size());
   EXPECT_EQ(1, factory->resolvers()[0]->request_count());
   EXPECT_EQ(3, factory->resolvers()[1]->request_count());
 }
 
 }  // namespace
 
 }  // namespace net