Standardize usage of virtual/override/final in content/renderer/

content/renderer/npapi/webplugin_delegate_proxy.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 "content/renderer/npapi/webplugin_delegate_proxy.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
@@ skipping 83 matching lines @@
 
 // Proxy for WebPluginResourceClient.  The object owns itself after creation,
 // deleting itself after its callback has been called.
 class ResourceClientProxy : public WebPluginResourceClient {
  public:
   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
     : channel_(channel), instance_id_(instance_id), resource_id_(0),
       multibyte_response_expected_(false) {
   }
 
-  virtual ~ResourceClientProxy() {
-  }
+  ~ResourceClientProxy() override {}
 
   void Initialize(unsigned long resource_id, const GURL& url, int notify_id) {
     resource_id_ = resource_id;
     channel_->Send(new PluginMsg_HandleURLRequestReply(
         instance_id_, resource_id, url, notify_id));
   }
 
   void InitializeForSeekableStream(unsigned long resource_id,
                                    int range_request_id) {
     resource_id_ = resource_id;
     multibyte_response_expected_ = true;
     channel_->Send(new PluginMsg_HTTPRangeRequestReply(
         instance_id_, resource_id, range_request_id));
   }
 
   // PluginResourceClient implementation:
-  virtual void WillSendRequest(const GURL& url, int http_status_code) override {
+  void WillSendRequest(const GURL& url, int http_status_code) override {
     DCHECK(channel_.get() != NULL);
     channel_->Send(new PluginMsg_WillSendRequest(
         instance_id_, resource_id_, url, http_status_code));
   }
 
-  virtual void DidReceiveResponse(const std::string& mime_type,
-                                  const std::string& headers,
-                                  uint32 expected_length,
-                                  uint32 last_modified,
-                                  bool request_is_seekable) override {
+  void DidReceiveResponse(const std::string& mime_type,
+                          const std::string& headers,
+                          uint32 expected_length,
+                          uint32 last_modified,
+                          bool request_is_seekable) override {
     DCHECK(channel_.get() != NULL);
     PluginMsg_DidReceiveResponseParams params;
     params.id = resource_id_;
     params.mime_type = mime_type;
     params.headers = headers;
     params.expected_length = expected_length;
     params.last_modified = last_modified;
     params.request_is_seekable = request_is_seekable;
     // Grab a reference on the underlying channel so it does not get
     // deleted from under us.
     scoped_refptr<PluginChannelHost> channel_ref(channel_);
     channel_->Send(new PluginMsg_DidReceiveResponse(instance_id_, params));
   }
 
-  virtual void DidReceiveData(const char* buffer,
-                              int length,
-                              int data_offset) override {
+  void DidReceiveData(const char* buffer,
+                      int length,
+                      int data_offset) override {
     DCHECK(channel_.get() != NULL);
     DCHECK_GT(length, 0);
     std::vector<char> data;
     data.resize(static_cast<size_t>(length));
     memcpy(&data.front(), buffer, length);
     // Grab a reference on the underlying channel so it does not get
     // deleted from under us.
     scoped_refptr<PluginChannelHost> channel_ref(channel_);
     channel_->Send(new PluginMsg_DidReceiveData(instance_id_, resource_id_,
                                                 data, data_offset));
   }
 
-  virtual void DidFinishLoading(unsigned long resource_id) override {
+  void DidFinishLoading(unsigned long resource_id) override {
     DCHECK(channel_.get() != NULL);
     DCHECK_EQ(resource_id, resource_id_);
     channel_->Send(new PluginMsg_DidFinishLoading(instance_id_, resource_id_));
     channel_ = NULL;
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
-  virtual void DidFail(unsigned long resource_id) override {
+  void DidFail(unsigned long resource_id) override {
     DCHECK(channel_.get() != NULL);
     DCHECK_EQ(resource_id, resource_id_);
     channel_->Send(new PluginMsg_DidFail(instance_id_, resource_id_));
     channel_ = NULL;
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
-  virtual bool IsMultiByteResponseExpected() override {
+  bool IsMultiByteResponseExpected() override {
     return multibyte_response_expected_;
   }
 
-  virtual int ResourceId() override {
-    return resource_id_;
-  }
+  int ResourceId() override { return resource_id_; }
 
  private:
   scoped_refptr<PluginChannelHost> channel_;
   int instance_id_;
   unsigned long resource_id_;
   // Set to true if the response expected is a multibyte response.
   // For e.g. response for a HTTP byte range request.
   bool multibyte_response_expected_;
 };
 
@@ skipping 1045 matching lines @@
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 void WebPluginDelegateProxy::OnCheckIfRunInsecureContent(const GURL& url,
                                                          bool* result) {
   *result = plugin_->CheckIfRunInsecureContent(url);
 }
 
 }  // namespace content