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

content/common/dwrite_font_platform_win.cc

 // Copyright 2014 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/public/common/dwrite_font_platform_win.h"
 
 #include <dwrite.h>
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 135 matching lines @@
 // collection as specified by DirectWrite. We also use this class for storing
 // some state information as this is one of the centralized entity.
 class FontCollectionLoader
     : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                 IDWriteFontCollectionLoader> {
  public:
   FontCollectionLoader()
       : in_collection_building_mode_(false),
         create_static_cache_(false) {}
 
-  virtual ~FontCollectionLoader();
+  ~FontCollectionLoader() override;
 
   HRESULT RuntimeClassInitialize() {
     return S_OK;
   }
 
   // IDWriteFontCollectionLoader methods.
-  virtual HRESULT STDMETHODCALLTYPE
-      CreateEnumeratorFromKey(
-          IDWriteFactory* factory,
-          void const* key,
-          UINT32 key_size,
-          IDWriteFontFileEnumerator** file_enumerator) override;
+  HRESULT STDMETHODCALLTYPE
+  CreateEnumeratorFromKey(IDWriteFactory* factory,
+                          void const* key,
+                          UINT32 key_size,
+                          IDWriteFontFileEnumerator** file_enumerator) override;
 
   // Does all the initialization for required loading fonts from registry.
   static HRESULT Initialize(IDWriteFactory* factory);
 
   // Returns font cache map size.
   UINT32 GetFontMapSize();
 
   // Returns font name string when given font index.
   base::string16 GetFontNameFromKey(UINT32 idx);
 
@@ skipping 307 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FontCacheWriter);
 };
 
 // Class implements IDWriteFontFileStream interface as required by direct write.
 class FontFileStream
     : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                 IDWriteFontFileStream> {
  public:
   // IDWriteFontFileStream methods.
-  virtual HRESULT STDMETHODCALLTYPE ReadFileFragment(
+  HRESULT STDMETHODCALLTYPE ReadFileFragment(
       void const** fragment_start,
       UINT64 file_offset,
       UINT64 fragment_size,
       void** context) override {
     if (cached_data_) {
       *fragment_start = g_font_loader->GetCachedFragment(font_key_,
                                                          file_offset,
                                                          fragment_size);
       if (*fragment_start == NULL) {
         DCHECK(false);
@@ skipping 12 matching lines @@
     if (g_font_loader->IsBuildStaticCacheMode()) {
       FontCacheWriter* cache_writer = g_font_loader->GetFontCacheWriter();
       cache_writer->AddRegion(writer_cookie_,
                               file_offset,
                               fragment_size,
                               static_cast<const BYTE*>(*fragment_start));
     }
     return S_OK;
   }
 
-  virtual void STDMETHODCALLTYPE ReleaseFileFragment(void* context) override {}
+  void STDMETHODCALLTYPE ReleaseFileFragment(void* context) override {}
 
-  virtual HRESULT STDMETHODCALLTYPE GetFileSize(UINT64* file_size) override {
+  HRESULT STDMETHODCALLTYPE GetFileSize(UINT64* file_size) override {
     if (cached_data_) {
       *file_size = g_font_loader->GetCachedFileSize(font_key_);
       return S_OK;
     }
 
     if (!memory_.get() || !memory_->IsValid())
       return E_FAIL;
 
     *file_size = memory_->length();
     return S_OK;
   }
 
-  virtual HRESULT STDMETHODCALLTYPE GetLastWriteTime(
-      UINT64* last_write_time) override {
+  HRESULT STDMETHODCALLTYPE GetLastWriteTime(UINT64* last_write_time) override {
     if (cached_data_) {
       *last_write_time = 0;
       return S_OK;
     }
 
     if (!memory_.get() || !memory_->IsValid())
       return E_FAIL;
 
     // According to MSDN article http://goo.gl/rrSYzi the "last modified time"
     // is used by DirectWrite font selection algorithms to determine whether
@@ skipping 60 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FontFileStream);
 };
 
 // Implements IDWriteFontFileLoader as required by FontFileLoader.
 class FontFileLoader
     : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                 IDWriteFontFileLoader> {
  public:
   // IDWriteFontFileLoader methods.
-  virtual HRESULT STDMETHODCALLTYPE
+  HRESULT STDMETHODCALLTYPE
   CreateStreamFromKey(void const* ref_key,
                       UINT32 ref_key_size,
                       IDWriteFontFileStream** stream) override {
     if (ref_key_size != sizeof(UINT32))
       return E_FAIL;
 
     UINT32 font_key = *static_cast<const UINT32*>(ref_key);
     mswr::ComPtr<FontFileStream> font_stream;
     HRESULT hr = mswr::MakeAndInitialize<FontFileStream>(&font_stream,
                                                          font_key);
     if (SUCCEEDED(hr)) {
       *stream = font_stream.Detach();
       return S_OK;
     }
     return E_FAIL;
   }
 
   FontFileLoader() {}
-  virtual ~FontFileLoader() {}
+  ~FontFileLoader() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FontFileLoader);
 };
 
 // Implements IDWriteFontFileEnumerator as required by direct write.
 class FontFileEnumerator
     : public mswr::RuntimeClass<mswr::RuntimeClassFlags<mswr::ClassicCom>,
                                 IDWriteFontFileEnumerator> {
  public:
   // IDWriteFontFileEnumerator methods.
-  virtual HRESULT STDMETHODCALLTYPE MoveNext(BOOL* has_current_file) override {
+  HRESULT STDMETHODCALLTYPE MoveNext(BOOL* has_current_file) override {
     *has_current_file = FALSE;
 
     if (current_file_)
       current_file_.ReleaseAndGetAddressOf();
 
     if (font_idx_ < g_font_loader->GetFontMapSize()) {
       HRESULT hr =
           factory_->CreateCustomFontFileReference(&font_idx_,
                                                   sizeof(UINT32),
                                                   file_loader_.Get(),
                                                   current_file_.GetAddressOf());
       DCHECK(SUCCEEDED(hr));
       *has_current_file = TRUE;
       font_idx_++;
     }
     return S_OK;
   }
 
-  virtual HRESULT STDMETHODCALLTYPE
+  HRESULT STDMETHODCALLTYPE
   GetCurrentFontFile(IDWriteFontFile** font_file) override {
     if (!current_file_) {
       *font_file = NULL;
       return E_FAIL;
     }
 
     *font_file = current_file_.Detach();
     return S_OK;
   }
 
   FontFileEnumerator(const void* keys,
                      UINT32 buffer_size,
                      IDWriteFactory* factory,
                      IDWriteFontFileLoader* file_loader)
       : factory_(factory), file_loader_(file_loader), font_idx_(0) {}
 
-  virtual ~FontFileEnumerator() {}
+  ~FontFileEnumerator() override {}
 
   mswr::ComPtr<IDWriteFactory> factory_;
   mswr::ComPtr<IDWriteFontFile> current_file_;
   mswr::ComPtr<IDWriteFontFileLoader> file_loader_;
   UINT32 font_idx_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FontFileEnumerator);
 };
 
@@ skipping 516 matching lines @@
   g_shared_font_cache.Set(mapping);
 
   return true;
 }
 
 bool BuildFontCache(const base::FilePath& file) {
   return BuildFontCacheInternal(file.value().c_str());
 }
 
 }  // namespace content