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

ppapi/proxy/raw_var_data.h

 // Copyright (c) 2013 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.
 
 #ifndef PPAPI_PROXY_RAW_VAR_DATA_H_
 #define PPAPI_PROXY_RAW_VAR_DATA_H_
 
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 111 matching lines @@
   bool initialized() { return initialized_; }
 
  protected:
   bool initialized_;
 };
 
 // A RawVarData class for PP_Vars which are value types.
 class BasicRawVarData : public RawVarData {
  public:
   BasicRawVarData();
-  virtual ~BasicRawVarData();
+  ~BasicRawVarData() override;
 
   // RawVarData implementation.
-  virtual PP_VarType Type() override;
-  virtual bool Init(const PP_Var& var, PP_Instance instance) override;
-  virtual PP_Var CreatePPVar(PP_Instance instance) override;
-  virtual void PopulatePPVar(const PP_Var& var,
-                             const std::vector<PP_Var>& graph) override;
-  virtual void Write(IPC::Message* m,
-                     const HandleWriter& handle_writer) override;
-  virtual bool Read(PP_VarType type,
-                    const IPC::Message* m,
-                    PickleIterator* iter) override;
+  PP_VarType Type() override;
+  bool Init(const PP_Var& var, PP_Instance instance) override;
+  PP_Var CreatePPVar(PP_Instance instance) override;
+  void PopulatePPVar(const PP_Var& var,
+                     const std::vector<PP_Var>& graph) override;
+  void Write(IPC::Message* m, const HandleWriter& handle_writer) override;
+  bool Read(PP_VarType type,
+            const IPC::Message* m,
+            PickleIterator* iter) override;
 
  private:
   PP_Var var_;
 };
 
 // A RawVarData class for string PP_Vars.
 class StringRawVarData : public RawVarData {
  public:
   StringRawVarData();
-  virtual ~StringRawVarData();
+  ~StringRawVarData() override;
 
   // RawVarData implementation.
-  virtual PP_VarType Type() override;
-  virtual bool Init(const PP_Var& var, PP_Instance instance) override;
-  virtual PP_Var CreatePPVar(PP_Instance instance) override;
-  virtual void PopulatePPVar(const PP_Var& var,
-                             const std::vector<PP_Var>& graph) override;
-  virtual void Write(IPC::Message* m,
-                     const HandleWriter& handle_writer) override;
-  virtual bool Read(PP_VarType type,
-                    const IPC::Message* m,
-                    PickleIterator* iter) override;
+  PP_VarType Type() override;
+  bool Init(const PP_Var& var, PP_Instance instance) override;
+  PP_Var CreatePPVar(PP_Instance instance) override;
+  void PopulatePPVar(const PP_Var& var,
+                     const std::vector<PP_Var>& graph) override;
+  void Write(IPC::Message* m, const HandleWriter& handle_writer) override;
+  bool Read(PP_VarType type,
+            const IPC::Message* m,
+            PickleIterator* iter) override;
 
  private:
   // The data in the string.
   std::string data_;
 };
 
 // A RawVarData class for array buffer PP_Vars.
 class ArrayBufferRawVarData : public RawVarData {
  public:
   // Enum for array buffer message types.
   enum ShmemType {
     ARRAY_BUFFER_NO_SHMEM,
     ARRAY_BUFFER_SHMEM_HOST,
     ARRAY_BUFFER_SHMEM_PLUGIN,
   };
 
   ArrayBufferRawVarData();
-  virtual ~ArrayBufferRawVarData();
+  ~ArrayBufferRawVarData() override;
 
   // RawVarData implementation.
-  virtual PP_VarType Type() override;
-  virtual bool Init(const PP_Var& var, PP_Instance instance) override;
-  virtual PP_Var CreatePPVar(PP_Instance instance) override;
-  virtual void PopulatePPVar(const PP_Var& var,
-                             const std::vector<PP_Var>& graph) override;
-  virtual void Write(IPC::Message* m,
-                     const HandleWriter& handle_writer) override;
-  virtual bool Read(PP_VarType type,
-                    const IPC::Message* m,
-                    PickleIterator* iter) override;
-  virtual SerializedHandle* GetHandle() override;
+  PP_VarType Type() override;
+  bool Init(const PP_Var& var, PP_Instance instance) override;
+  PP_Var CreatePPVar(PP_Instance instance) override;
+  void PopulatePPVar(const PP_Var& var,
+                     const std::vector<PP_Var>& graph) override;
+  void Write(IPC::Message* m, const HandleWriter& handle_writer) override;
+  bool Read(PP_VarType type,
+            const IPC::Message* m,
+            PickleIterator* iter) override;
+  SerializedHandle* GetHandle() override;
 
  private:
   // The type of the storage underlying the array buffer.
   ShmemType type_;
   // The data in the buffer. Valid for |type_| == ARRAY_BUFFER_NO_SHMEM.
   std::string data_;
   // Host shmem handle. Valid for |type_| == ARRAY_BUFFER_SHMEM_HOST.
   int host_shm_handle_id_;
   // Plugin shmem handle. Valid for |type_| == ARRAY_BUFFER_SHMEM_PLUGIN.
   SerializedHandle plugin_shm_handle_;
 };
 
 // A RawVarData class for array PP_Vars.
 class ArrayRawVarData : public RawVarData {
  public:
   ArrayRawVarData();
-  virtual ~ArrayRawVarData();
+  ~ArrayRawVarData() override;
 
   void AddChild(size_t element);
 
   // RawVarData implementation.
-  virtual PP_VarType Type() override;
-  virtual bool Init(const PP_Var& var, PP_Instance instance) override;
-  virtual PP_Var CreatePPVar(PP_Instance instance) override;
-  virtual void PopulatePPVar(const PP_Var& var,
-                             const std::vector<PP_Var>& graph) override;
-  virtual void Write(IPC::Message* m,
-                     const HandleWriter& handle_writer) override;
-  virtual bool Read(PP_VarType type,
-                    const IPC::Message* m,
-                    PickleIterator* iter) override;
+  PP_VarType Type() override;
+  bool Init(const PP_Var& var, PP_Instance instance) override;
+  PP_Var CreatePPVar(PP_Instance instance) override;
+  void PopulatePPVar(const PP_Var& var,
+                     const std::vector<PP_Var>& graph) override;
+  void Write(IPC::Message* m, const HandleWriter& handle_writer) override;
+  bool Read(PP_VarType type,
+            const IPC::Message* m,
+            PickleIterator* iter) override;
 
  private:
   std::vector<size_t> children_;
 };
 
 // A RawVarData class for dictionary PP_Vars.
 class DictionaryRawVarData : public RawVarData {
  public:
   DictionaryRawVarData();
-  virtual ~DictionaryRawVarData();
+  ~DictionaryRawVarData() override;
 
   void AddChild(const std::string& key, size_t value);
 
   // RawVarData implementation.
-  virtual PP_VarType Type() override;
-  virtual bool Init(const PP_Var& var, PP_Instance instance) override;
-  virtual PP_Var CreatePPVar(PP_Instance instance) override;
-  virtual void PopulatePPVar(const PP_Var& var,
-                             const std::vector<PP_Var>& graph) override;
-  virtual void Write(IPC::Message* m,
-                     const HandleWriter& handle_writer) override;
-  virtual bool Read(PP_VarType type,
-                    const IPC::Message* m,
-                    PickleIterator* iter) override;
+  PP_VarType Type() override;
+  bool Init(const PP_Var& var, PP_Instance instance) override;
+  PP_Var CreatePPVar(PP_Instance instance) override;
+  void PopulatePPVar(const PP_Var& var,
+                     const std::vector<PP_Var>& graph) override;
+  void Write(IPC::Message* m, const HandleWriter& handle_writer) override;
+  bool Read(PP_VarType type,
+            const IPC::Message* m,
+            PickleIterator* iter) override;
 
  private:
   std::vector<std::pair<std::string, size_t> > children_;
 };
 
 // A RawVarData class for resource PP_Vars.
 // This class does not hold a reference on the PP_Resource that is being
 // serialized. If sending a resource from the plugin to the host, the plugin
 // should not release the ResourceVar before sending the serialized message to
 // the host, and the host should immediately consume the ResourceVar before
 // processing further messages.
 class ResourceRawVarData : public RawVarData {
  public:
   ResourceRawVarData();
-  virtual ~ResourceRawVarData();
+  ~ResourceRawVarData() override;
 
   // RawVarData implementation.
-  virtual PP_VarType Type() override;
-  virtual bool Init(const PP_Var& var, PP_Instance instance) override;
-  virtual PP_Var CreatePPVar(PP_Instance instance) override;
-  virtual void PopulatePPVar(const PP_Var& var,
-                             const std::vector<PP_Var>& graph) override;
-  virtual void Write(IPC::Message* m,
-                     const HandleWriter& handle_writer) override;
-  virtual bool Read(PP_VarType type,
-                    const IPC::Message* m,
-                    PickleIterator* iter) override;
+  PP_VarType Type() override;
+  bool Init(const PP_Var& var, PP_Instance instance) override;
+  PP_Var CreatePPVar(PP_Instance instance) override;
+  void PopulatePPVar(const PP_Var& var,
+                     const std::vector<PP_Var>& graph) override;
+  void Write(IPC::Message* m, const HandleWriter& handle_writer) override;
+  bool Read(PP_VarType type,
+            const IPC::Message* m,
+            PickleIterator* iter) override;
 
  private:
   // Resource ID in the plugin. If one has not yet been created, this is 0.
   // This is a borrowed reference; the resource's refcount is not incremented.
   PP_Resource pp_resource_;
 
   // Pending resource host ID in the renderer.
   int pending_renderer_host_id_;
 
   // Pending resource host ID in the browser.
   int pending_browser_host_id_;
 
   // A message containing information about how to create a plugin-side
   // resource. The message type will vary based on the resource type, and will
   // usually contain a pending resource host ID, and other required information.
   // If the resource was created directly, this is NULL.
   scoped_ptr<IPC::Message> creation_message_;
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_RAW_VAR_DATA_H_