Update {virtual,override,final} to follow C++11 style.

android_webview/browser/net/android_stream_reader_url_request_job_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 "android_webview/browser/input_stream.h"
 #include "android_webview/browser/net/android_stream_reader_url_request_job.h"
 #include "android_webview/browser/net/aw_url_request_job_factory.h"
 #include "android_webview/browser/net/input_stream_reader.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 33 matching lines @@
 using testing::WithArgs;
 using testing::_;
 
 // Some of the classes will DCHECK on a null InputStream (which is desirable).
 // The workaround is to use this class. None of the methods need to be
 // implemented as the mock InputStreamReader should never forward calls to the
 // InputStream.
 class NotImplInputStream : public InputStream {
  public:
   NotImplInputStream() {}
-  virtual ~NotImplInputStream() {}
-  virtual bool BytesAvailable(int* bytes_available) const override {
+  ~NotImplInputStream() override {}
+  bool BytesAvailable(int* bytes_available) const override {
     NOTIMPLEMENTED();
     return false;
   }
-  virtual bool Skip(int64_t n, int64_t* bytes_skipped) override {
+  bool Skip(int64_t n, int64_t* bytes_skipped) override {
     NOTIMPLEMENTED();
     return false;
   }
-  virtual bool Read(net::IOBuffer* dest, int length, int* bytes_read) override {
+  bool Read(net::IOBuffer* dest, int length, int* bytes_read) override {
     NOTIMPLEMENTED();
     return false;
   }
 };
 
 // Required in order to create an instance of AndroidStreamReaderURLRequestJob.
 class StreamReaderDelegate :
     public AndroidStreamReaderURLRequestJob::Delegate {
  public:
   StreamReaderDelegate() {}
 
-  virtual scoped_ptr<InputStream> OpenInputStream(
-      JNIEnv* env,
-      const GURL& url) override {
+  scoped_ptr<InputStream> OpenInputStream(JNIEnv* env,
+                                          const GURL& url) override {
     return make_scoped_ptr<InputStream>(new NotImplInputStream());
   }
 
-  virtual void OnInputStreamOpenFailed(net::URLRequest* request,
-                                       bool* restart) override {
+  void OnInputStreamOpenFailed(net::URLRequest* request,
+                               bool* restart) override {
     *restart = false;
   }
 
-  virtual bool GetMimeType(JNIEnv* env,
-                           net::URLRequest* request,
-                           android_webview::InputStream* stream,
-                           std::string* mime_type) override {
+  bool GetMimeType(JNIEnv* env,
+                   net::URLRequest* request,
+                   android_webview::InputStream* stream,
+                   std::string* mime_type) override {
     return false;
   }
 
-  virtual bool GetCharset(JNIEnv* env,
-                          net::URLRequest* request,
-                          android_webview::InputStream* stream,
-                          std::string* charset) override {
+  bool GetCharset(JNIEnv* env,
+                  net::URLRequest* request,
+                  android_webview::InputStream* stream,
+                  std::string* charset) override {
     return false;
   }
 
-  virtual void AppendResponseHeaders(
-      JNIEnv* env,
-      net::HttpResponseHeaders* headers) override {
+  void AppendResponseHeaders(JNIEnv* env,
+                             net::HttpResponseHeaders* headers) override {
     // no-op
   }
 };
 
 class NullStreamReaderDelegate : public StreamReaderDelegate {
  public:
   NullStreamReaderDelegate() {}
 
-  virtual scoped_ptr<InputStream> OpenInputStream(
-      JNIEnv* env,
-      const GURL& url) override {
+  scoped_ptr<InputStream> OpenInputStream(JNIEnv* env,
+                                          const GURL& url) override {
     return make_scoped_ptr<InputStream>(NULL);
   }
 };
 
 class HeaderAlteringStreamReaderDelegate : public NullStreamReaderDelegate {
  public:
   HeaderAlteringStreamReaderDelegate() {}
 
-  virtual void AppendResponseHeaders(
-      JNIEnv* env,
-      net::HttpResponseHeaders* headers) override {
+  void AppendResponseHeaders(JNIEnv* env,
+                             net::HttpResponseHeaders* headers) override {
     headers->ReplaceStatusLine(kStatusLine);
     std::string headerLine(kCustomHeaderName);
     headerLine.append(": ");
     headerLine.append(kCustomHeaderValue);
     headers->AddHeader(headerLine);
   }
 
   static const int kResponseCode;
   static const char* kStatusLine;
   static const char* kCustomHeaderName;
@@ skipping 25 matching lines @@
       net::NetworkDelegate* network_delegate,
       scoped_ptr<Delegate> delegate,
       scoped_ptr<InputStreamReader> stream_reader)
       : AndroidStreamReaderURLRequestJob(request,
                                          network_delegate,
                                          delegate.Pass()),
         stream_reader_(stream_reader.Pass()) {
     message_loop_proxy_ = base::MessageLoopProxy::current();
   }
 
-  virtual scoped_ptr<InputStreamReader> CreateStreamReader(
+  scoped_ptr<InputStreamReader> CreateStreamReader(

[boliu, 2015/02/04 01:04:38]

this one was already missing override, so now looks super ambiguous without
virtual

[boliu, 2015/02/04 01:06:15]

Wahh I can't read.

       InputStream* stream) override {
     return stream_reader_.Pass();
   }
  protected:
-  virtual ~TestStreamReaderJob() {}
+  ~TestStreamReaderJob() override {}
 
-  virtual base::TaskRunner* GetWorkerThreadRunner() override {
+  base::TaskRunner* GetWorkerThreadRunner() override {
     return message_loop_proxy_.get();
   }
 
   scoped_ptr<InputStreamReader> stream_reader_;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
 };
 
 class AndroidStreamReaderURLRequestJobTest : public Test {
  public:
   AndroidStreamReaderURLRequestJobTest() {}
 
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
     context_.set_job_factory(&factory_);
     context_.set_network_delegate(&network_delegate_);
     req_ = context_.CreateRequest(GURL("content://foo"),
                                   net::DEFAULT_PRIORITY,
                                   &url_request_delegate_,
                                   NULL);
     req_->set_method("GET");
   }
 
   void SetRange(net::URLRequest* req, int first_byte, int last_byte) {
@@ skipping 209 matching lines @@
 
   SetRange(req_.get(), offset, bytes_available);
   req_->Start();
 
   loop.Run();
 
   EXPECT_EQ(0, network_delegate_.completed_requests());
   req_->Cancel();
   EXPECT_EQ(1, network_delegate_.completed_requests());
 }