Linux/ChromeOS Chromium style checker cleanup, content/ edition.

content/common/resource_dispatcher_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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process.h"
@@ skipping 54 matching lines @@
                               int encoded_data_length) OVERRIDE {
     EXPECT_FALSE(complete_);
     data_.append(data, data_length);
     total_encoded_data_length_ += encoded_data_length;
   }
 
   virtual void OnCompletedRequest(
       int error_code,
       bool was_ignored_by_handler,
       const std::string& security_info,
-      const base::TimeTicks& completion_time) {
+      const base::TimeTicks& completion_time) OVERRIDE {
     EXPECT_FALSE(complete_);
     complete_ = true;
   }
 
   bool complete() const {
     return complete_;
   }
   const std::string& data() const {
     return data_;
   }
   int total_encoded_data_length() const {
     return total_encoded_data_length_;
   }
 
  private:
   bool complete_;
   std::string data_;
   int total_encoded_data_length_;
 };
 
 
 // Sets up the message sender override for the unit test
 class ResourceDispatcherTest : public testing::Test, public IPC::Sender {
  public:
   // Emulates IPC send operations (IPC::Sender) by adding
   // pending messages to the queue.
-  virtual bool Send(IPC::Message* msg) {
+  virtual bool Send(IPC::Message* msg) OVERRIDE {
     message_queue_.push_back(IPC::Message(*msg));
     delete msg;
     return true;
   }
 
   // Emulates the browser process and processes the pending IPC messages,
   // returning the hardcoded file contents.
   void ProcessMessages() {
     while (!message_queue_.empty()) {
       int request_id;
@@ skipping 178 matching lines @@
                               int data_length,
                               int encoded_data_length) OVERRIDE {
     EXPECT_EQ(defer_loading_, false);
     set_defer_loading(false);
   }
 
   virtual void OnCompletedRequest(
       int error_code,
       bool was_ignored_by_handler,
       const std::string& security_info,
-      const base::TimeTicks& completion_time) {
+      const base::TimeTicks& completion_time) OVERRIDE {
   }
 
  protected:
   virtual void SetUp() OVERRIDE {
     ResourceDispatcherTest::SetUp();
     shared_handle_.Delete(kShmemSegmentName);
     EXPECT_TRUE(shared_handle_.CreateNamed(kShmemSegmentName, false, 100));
   }
 
   virtual void TearDown() OVERRIDE {
@@ skipping 46 matching lines @@
   }
 
   // ResourceLoaderBridge::Peer methods.
   virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
   }
 
   virtual bool OnReceivedRedirect(
       const GURL& new_url,
       const ResourceResponseInfo& info,
       bool* has_new_first_party_for_cookies,
-      GURL* new_first_party_for_cookies) {
+      GURL* new_first_party_for_cookies) OVERRIDE {
     return true;
   }
 
   virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
     response_info_ = info;
   }
 
   virtual void OnDownloadedData(int len) OVERRIDE {
   }
 
@@ skipping 49 matching lines @@
   ResourceResponseHead response_head;
   response_head.error_code = net::OK;
 
   PerformTest(response_head);
 
   EXPECT_EQ(0, response_info().load_timing.base_ticks.ToInternalValue());
   EXPECT_EQ(-1, response_info().load_timing.dns_start);
 }
 
 }  // namespace content