Standardize usage of virtual/override/final in storage/

storage/browser/fileapi/obfuscated_file_util.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 "storage/browser/fileapi/obfuscated_file_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
@@ skipping 112 matching lines @@
     base::FilePath root_virtual_path = root_url.path();
     FileId file_id;
 
     if (!db_->GetFileWithPath(root_virtual_path, &file_id))
       return;
 
     FileRecord record = { file_id, root_virtual_path };
     recurse_queue_.push(record);
   }
 
-  virtual ~ObfuscatedFileEnumerator() {}
+  ~ObfuscatedFileEnumerator() override {}
 
-  virtual base::FilePath Next() override {
+  base::FilePath Next() override {
     ProcessRecurseQueue();
     if (display_stack_.empty())
       return base::FilePath();
 
     current_file_id_ = display_stack_.back();
     display_stack_.pop_back();
 
     FileInfo file_info;
     base::FilePath platform_file_path;
     base::File::Error error =
         obfuscated_file_util_->GetFileInfoInternal(
             db_, context_, root_url_, current_file_id_,
             &file_info, &current_platform_file_info_, &platform_file_path);
     if (error != base::File::FILE_OK)
       return Next();
 
     base::FilePath virtual_path =
         current_parent_virtual_path_.Append(file_info.name);
     if (recursive_ && file_info.is_directory()) {
       FileRecord record = { current_file_id_, virtual_path };
       recurse_queue_.push(record);
     }
     return virtual_path;
   }
 
-  virtual int64 Size() override {
-    return current_platform_file_info_.size;
-  }
+  int64 Size() override { return current_platform_file_info_.size; }
 
-  virtual base::Time LastModifiedTime() override {
+  base::Time LastModifiedTime() override {
     return current_platform_file_info_.last_modified;
   }
 
-  virtual bool IsDirectory() override {
+  bool IsDirectory() override {
     return current_platform_file_info_.is_directory;
   }
 
  private:
   typedef SandboxDirectoryDatabase::FileId FileId;
   typedef SandboxDirectoryDatabase::FileInfo FileInfo;
 
   struct FileRecord {
     FileId file_id;
     base::FilePath virtual_path;
@@ skipping 30 matching lines @@
  public:
   typedef SandboxOriginDatabase::OriginRecord OriginRecord;
   ObfuscatedOriginEnumerator(
       SandboxOriginDatabaseInterface* origin_database,
       const base::FilePath& base_file_path)
       : base_file_path_(base_file_path) {
     if (origin_database)
       origin_database->ListAllOrigins(&origins_);
   }
 
-  virtual ~ObfuscatedOriginEnumerator() {}
+  ~ObfuscatedOriginEnumerator() override {}
 
   // Returns the next origin.  Returns empty if there are no more origins.
-  virtual GURL Next() override {
+  GURL Next() override {
     OriginRecord record;
     if (!origins_.empty()) {
       record = origins_.back();
       origins_.pop_back();
     }
     current_ = record;
     return storage::GetOriginFromIdentifier(record.origin);
   }
 
   // Returns the current origin's information.
-  virtual bool HasTypeDirectory(const std::string& type_string) const override {
+  bool HasTypeDirectory(const std::string& type_string) const override {
     if (current_.path.empty())
       return false;
     if (type_string.empty()) {
       NOTREACHED();
       return false;
     }
     base::FilePath path =
         base_file_path_.Append(current_.path).AppendASCII(type_string);
     return base::DirectoryExists(path);
   }
@@ skipping 1163 matching lines @@
   }
   return file.Pass();
 }
 
 bool ObfuscatedFileUtil::HasIsolatedStorage(const GURL& origin) {
   return special_storage_policy_.get() &&
       special_storage_policy_->HasIsolatedStorage(origin);
 }
 
 }  // namespace storage