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

content/child/web_url_loader_impl_unittest.cc

 // Copyright 2014 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/child/web_url_loader_impl.h"
 
 #include <string.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 97 matching lines @@
         expect_multipart_response_(false),
         delete_on_receive_redirect_(false),
         delete_on_receive_response_(false),
         delete_on_receive_data_(false),
         delete_on_finish_(false),
         delete_on_fail_(false),
         did_receive_redirect_(false),
         did_receive_response_(false),
         did_finish_(false) {}
 
-  virtual ~TestWebURLLoaderClient() {}
+  ~TestWebURLLoaderClient() override {}
 
   // blink::WebURLLoaderClient implementation:
-  virtual void willSendRequest(
+  void willSendRequest(
       blink::WebURLLoader* loader,
       blink::WebURLRequest& newRequest,
       const blink::WebURLResponse& redirectResponse) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     // No test currently simulates mutiple redirects.
     EXPECT_FALSE(did_receive_redirect_);
     did_receive_redirect_ = true;
 
     if (delete_on_receive_redirect_)
       loader_.reset();
   }
 
-  virtual void didSendData(blink::WebURLLoader* loader,
-                           unsigned long long bytesSent,
-                           unsigned long long totalBytesToBeSent) override {
+  void didSendData(blink::WebURLLoader* loader,
+                   unsigned long long bytesSent,
+                   unsigned long long totalBytesToBeSent) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
 
-  virtual void didReceiveResponse(
+  void didReceiveResponse(
       blink::WebURLLoader* loader,
       const blink::WebURLResponse& response) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
 
     // Only multipart requests may receive multiple response headers.
     EXPECT_TRUE(expect_multipart_response_ || !did_receive_response_);
 
     did_receive_response_ = true;
     response_ = response;
     if (delete_on_receive_response_)
       loader_.reset();
   }
 
-  virtual void didDownloadData(blink::WebURLLoader* loader,
-                               int dataLength,
-                               int encodedDataLength) override {
+  void didDownloadData(blink::WebURLLoader* loader,
+                       int dataLength,
+                       int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
   }
 
-  virtual void didReceiveData(blink::WebURLLoader* loader,
-                              const char* data,
-                              int dataLength,
-                              int encodedDataLength) override {
+  void didReceiveData(blink::WebURLLoader* loader,
+                      const char* data,
+                      int dataLength,
+                      int encodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     // The response should have started, but must not have finished, or failed.
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     EXPECT_EQ(net::OK, error_.reason);
     EXPECT_EQ("", error_.domain.utf8());
 
     received_data_.append(data, dataLength);
 
     if (delete_on_receive_data_)
       loader_.reset();
   }
 
-  virtual void didReceiveCachedMetadata(blink::WebURLLoader* loader,
-                                        const char* data,
-                                        int dataLength) override {
+  void didReceiveCachedMetadata(blink::WebURLLoader* loader,
+                                const char* data,
+                                int dataLength) override {
     EXPECT_EQ(loader_.get(), loader);
   }
 
-  virtual void didFinishLoading(blink::WebURLLoader* loader,
-                                double finishTime,
-                                int64_t totalEncodedDataLength) override {
+  void didFinishLoading(blink::WebURLLoader* loader,
+                        double finishTime,
+                        int64_t totalEncodedDataLength) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     did_finish_ = true;
 
     if (delete_on_finish_)
       loader_.reset();
   }
 
-  virtual void didFail(blink::WebURLLoader* loader,
-                       const blink::WebURLError& error) override {
+  void didFail(blink::WebURLLoader* loader,
+               const blink::WebURLError& error) override {
     EXPECT_TRUE(loader_);
     EXPECT_EQ(loader_.get(), loader);
     EXPECT_FALSE(did_finish_);
     error_ = error;
 
     if (delete_on_fail_)
       loader_.reset();
   }
 
   WebURLLoaderImpl* loader() { return loader_.get(); }
@@ skipping 466 matching lines @@
   EXPECT_EQ(kMimeType, client()->response().mimeType().latin1());
 
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
   EXPECT_EQ(kTestData, client()->received_data());
 }
 
 }  // namespace
 }  // namespace content