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

content/browser/loader/resource_dispatcher_host_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 <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
@@ skipping 148 matching lines @@
 }
 
 class MockURLRequestContextSelector
     : public ResourceMessageFilter::URLRequestContextSelector {
  public:
   explicit MockURLRequestContextSelector(
       net::URLRequestContext* request_context)
       : request_context_(request_context) {}
 
   virtual net::URLRequestContext* GetRequestContext(
-      ResourceType::Type request_type) {
+      ResourceType::Type request_type) OVERRIDE {
     return request_context_;
   }
 
  private:
   net::URLRequestContext* const request_context_;
 };
 
 // This class forwards the incoming messages to the ResourceDispatcherHostTest.
 // This is used to emulate different sub-processes, since this filter will
 // have a different ID than the original. For the test, we want all the incoming
 // messages to go to the same place, which is why this forwards.
 class ForwardingFilter : public ResourceMessageFilter {
  public:
   explicit ForwardingFilter(IPC::Sender* dest,
                             ResourceContext* resource_context)
     : ResourceMessageFilter(
         ChildProcessHostImpl::GenerateChildProcessUniqueId(),
         PROCESS_TYPE_RENDERER,
         resource_context, NULL, NULL, NULL,
         new MockURLRequestContextSelector(
             resource_context->GetRequestContext())),
       dest_(dest) {
     OnChannelConnected(base::GetCurrentProcId());
   }
 
   // ResourceMessageFilter override
-  virtual bool Send(IPC::Message* msg) {
+  virtual bool Send(IPC::Message* msg) OVERRIDE {
     if (!dest_)
       return false;
     return dest_->Send(msg);
   }
 
  protected:
   virtual ~ForwardingFilter() {}
 
  private:
   IPC::Sender* dest_;
@@ skipping 23 matching lines @@
                                 bool auto_advance)
       : net::URLRequestTestJob(request,
                                network_delegate,
                                response_headers,
                                response_data,
                                auto_advance) {
     Init();
   }
 
   // Do nothing until you're told to.
-  virtual void Start() {}
+  virtual void Start() OVERRIDE {}
 
   // Finish starting a URL request whose job is an instance of
   // URLRequestTestDelayedStartJob.  It is illegal to call this routine
   // with a URLRequest that does not use URLRequestTestDelayedStartJob.
   static void CompleteStart(net::URLRequest* request) {
     for (URLRequestTestDelayedStartJob* job = list_head_;
          job;
          job = job->next_) {
       if (job->request() == request) {
         job->net::URLRequestTestJob::Start();
@@ skipping 57 matching lines @@
                                      const std::string& response_headers,
                                      const std::string& response_data,
                                      bool auto_advance)
       : net::URLRequestTestJob(request,
                                network_delegate,
                                response_headers,
                                response_data,
                                auto_advance) {}
 
  protected:
-  ~URLRequestTestDelayedCompletionJob() {}
+  virtual ~URLRequestTestDelayedCompletionJob() {}
 
  private:
   virtual bool NextReadAsync() OVERRIDE { return true; }
 };
 
 class URLRequestBigJob : public net::URLRequestSimpleJob {
  public:
   URLRequestBigJob(net::URLRequest* request,
                    net::NetworkDelegate* network_delegate)
       : net::URLRequestSimpleJob(request, network_delegate) {
@@ skipping 34 matching lines @@
   }
 };
 
 // Associated with an URLRequest to determine if the URLRequest gets deleted.
 class TestUserData : public base::SupportsUserData::Data {
  public:
   explicit TestUserData(bool* was_deleted)
       : was_deleted_(was_deleted) {
   }
 
-  ~TestUserData() {
+  virtual ~TestUserData() {
     *was_deleted_ = true;
   }
 
  private:
   bool* was_deleted_;
 };
 
 class TransfersAllNavigationsContentBrowserClient
     : public TestContentBrowserClient {
  public:
   virtual bool ShouldSwapProcessesForRedirect(ResourceContext* resource_context,
                                               const GURL& current_url,
-                                              const GURL& new_url) {
+                                              const GURL& new_url) OVERRIDE {
     return true;
   }
 };
 
 enum GenericResourceThrottleFlags {
   NONE                      = 0,
   DEFER_STARTING_REQUEST    = 1 << 0,
   DEFER_PROCESSING_RESPONSE = 1 << 1,
   CANCEL_BEFORE_START       = 1 << 2
 };
@@ skipping 131 matching lines @@
         old_factory_(NULL),
         resource_type_(ResourceType::SUB_RESOURCE),
         send_data_received_acks_(false) {
     browser_context_.reset(new TestBrowserContext());
     BrowserContext::EnsureResourceContextInitialized(browser_context_.get());
     message_loop_.RunUntilIdle();
     filter_ = new ForwardingFilter(
         this, browser_context_->GetResourceContext());
   }
   // IPC::Sender implementation
-  virtual bool Send(IPC::Message* msg) {
+  virtual bool Send(IPC::Message* msg) OVERRIDE {
     accum_.AddMessage(*msg);
 
     if (send_data_received_acks_ &&
         msg->type() == ResourceMsg_DataReceived::ID) {
       GenerateDataReceivedACK(*msg);
     }
 
     delete msg;
     return true;
   }
@@ skipping 1405 matching lines @@
     }
 
     MessageLoop::current()->RunUntilIdle();
 
     msgs.clear();
     accum_.GetClassifiedMessages(&msgs);
   }
 }
 
 }  // namespace content