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

chrome/browser/profile_resetter/jtl_interpreter.cc

 // Copyright 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.
 
 #include "chrome/browser/profile_resetter/jtl_interpreter.h"
 
 #include <numeric>
 
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 228 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(CompareStoredValue);
 };
 
 template<bool ExpectedTypeIsBooleanNotHashable>
 class StoreNodeValue : public Operation {
  public:
   explicit StoreNodeValue(const std::string& hashed_name)
       : hashed_name_(hashed_name) {
     DCHECK(base::IsStringUTF8(hashed_name));
   }
-  virtual ~StoreNodeValue() {}
-  virtual bool Execute(ExecutionContext* context) override {
+  ~StoreNodeValue() override {}
+  bool Execute(ExecutionContext* context) override {
     scoped_ptr<base::Value> value;
     if (ExpectedTypeIsBooleanNotHashable) {
       if (!context->current_node()->IsType(base::Value::TYPE_BOOLEAN))
         return true;
       value.reset(context->current_node()->DeepCopy());
     } else {
       std::string hash;
       if (!context->GetValueHash(*context->current_node(), &hash))
         return true;
       value.reset(new base::StringValue(hash));
@@ skipping 114 matching lines @@
  private:
   std::string hashed_value_;
   DISALLOW_COPY_AND_ASSIGN(CompareNodeHashNot);
 };
 
 template<bool ExpectedTypeIsBooleanNotHashable>
 class CompareNodeToStored : public Operation {
  public:
   explicit CompareNodeToStored(const std::string& hashed_name)
       : hashed_name_(hashed_name) {}
-  virtual ~CompareNodeToStored() {}
-  virtual bool Execute(ExecutionContext* context) override {
+  ~CompareNodeToStored() override {}
+  bool Execute(ExecutionContext* context) override {
     const base::Value* stored_value = NULL;
     if (!context->working_memory()->Get(hashed_name_, &stored_value))
       return true;
     if (ExpectedTypeIsBooleanNotHashable) {
       if (!context->current_node()->IsType(base::Value::TYPE_BOOLEAN) ||
           !context->current_node()->Equals(stored_value))
         return true;
     } else {
       std::string actual_hash;
       std::string stored_hash;
@@ skipping 340 matching lines @@
   return working_memory_->GetString(hashed_key, output);
 }
 
 int JtlInterpreter::CalculateProgramChecksum() const {
   uint8 digest[3] = {};
   crypto::SHA256HashString(program_, digest, arraysize(digest));
   return static_cast<uint32>(digest[0]) << 16 |
          static_cast<uint32>(digest[1]) << 8 |
          static_cast<uint32>(digest[2]);
 }