Enable strict-virtual-specifiers for iOS builds.

net/disk_cache/blockfile/file_ios.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 "net/disk_cache/blockfile/file.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/threading/worker_pool.h"
@@ skipping 29 matching lines @@
 
   // Read and Write are the operations that can be performed asynchronously.
   // The actual parameters for the operation are setup in the constructor of
   // the object. Both methods should be called from a worker thread, by posting
   // a task to the WorkerPool (they are RunnableMethods). When finished,
   // controller->OnIOComplete() is called.
   void Read();
   void Write();
 
  private:
-  virtual ~FileBackgroundIO() {}
+  ~FileBackgroundIO() override {}
 
   disk_cache::FileIOCallback* callback_;
 
   disk_cache::File* file_;
   const void* buf_;
   size_t buf_len_;
   size_t offset_;
 
   DISALLOW_COPY_AND_ASSIGN(FileBackgroundIO);
 };
 
 
 // The specialized controller that keeps track of current operations.
 class FileInFlightIO : public disk_cache::InFlightIO {
  public:
   FileInFlightIO() {}
-  virtual ~FileInFlightIO() {}
+  ~FileInFlightIO() override {}
 
   // These methods start an asynchronous operation. The arguments have the same
   // semantics of the File asynchronous operations, with the exception that the
   // operation never finishes synchronously.
   void PostRead(disk_cache::File* file, void* buf, size_t buf_len,
                 size_t offset, disk_cache::FileIOCallback* callback);
   void PostWrite(disk_cache::File* file, const void* buf, size_t buf_len,
                  size_t offset, disk_cache::FileIOCallback* callback);
 
  protected:
   // Invokes the users' completion callback at the end of the IO operation.
   // |cancel| is true if the actual task posted to the thread is still
   // queued (because we are inside WaitForPendingIO), and false if said task is
   // the one performing the call.
-  virtual void OnOperationComplete(disk_cache::BackgroundIO* operation,
-                                   bool cancel) override;
+  void OnOperationComplete(disk_cache::BackgroundIO* operation,
+                           bool cancel) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileInFlightIO);
 };
 
 // ---------------------------------------------------------------------------
 
 // Runs on a worker thread.
 void FileBackgroundIO::Read() {
   if (file_->Read(const_cast<void*>(buf_), buf_len_, offset_)) {
@@ skipping 194 matching lines @@
     return false;
 
   GetFileInFlightIO()->PostWrite(this, buffer, buffer_len, offset, callback);
 
   if (completed)
     *completed = false;
   return true;
 }
 
 }  // namespace disk_cache