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

content/renderer/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/webplugin_delegate_proxy.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #elif defined(USE_X11)
 #include <cairo/cairo.h>
@@ skipping 88 matching lines @@
 
 // Proxy for WebPluginResourceClient.  The object owns itself after creation,
 // deleting itself after its callback has been called.
 class ResourceClientProxy : public webkit::npapi::WebPluginResourceClient {
  public:
   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
     : channel_(channel), instance_id_(instance_id), resource_id_(0),
       multibyte_response_expected_(false) {
   }
 
-  ~ResourceClientProxy() {
+  virtual ~ResourceClientProxy() {
   }
 
   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:
-  void WillSendRequest(const GURL& url, int http_status_code) {
+  virtual void WillSendRequest(const GURL& url, int http_status_code) OVERRIDE {
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_WillSendRequest(instance_id_, resource_id_,
                                                  url, http_status_code));
   }
 
-  void DidReceiveResponse(const std::string& mime_type,
-                          const std::string& headers,
-                          uint32 expected_length,
-                          uint32 last_modified,
-                          bool request_is_seekable) {
+  virtual void DidReceiveResponse(const std::string& mime_type,
+                                  const std::string& headers,
+                                  uint32 expected_length,
+                                  uint32 last_modified,
+                                  bool request_is_seekable) OVERRIDE {
     DCHECK(channel_ != 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));
   }
 
-  void DidReceiveData(const char* buffer, int length, int data_offset) {
+  virtual void DidReceiveData(const char* buffer,
+                              int length,
+                              int data_offset) OVERRIDE {
     DCHECK(channel_ != 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));
   }
 
-  void DidFinishLoading() {
+  virtual void DidFinishLoading() OVERRIDE {
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_DidFinishLoading(instance_id_, resource_id_));
     channel_ = NULL;
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
-  void DidFail() {
+  virtual void DidFail() OVERRIDE {
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_DidFail(instance_id_, resource_id_));
     channel_ = NULL;
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
-  bool IsMultiByteResponseExpected() {
+  virtual bool IsMultiByteResponseExpected() OVERRIDE {
     return multibyte_response_expected_;
   }
 
-  int ResourceId() {
+  virtual 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 1108 matching lines @@
 
 void WebPluginDelegateProxy::OnURLRedirectResponse(bool allow,
                                                    int resource_id) {
   if (!plugin_)
     return;
 
   plugin_->URLRedirectResponse(allow, resource_id);
 }
 
 }  // namespace content