replace OVERRIDE and FINAL with override and final in chrome/browser/[j-q]*

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 95 matching lines @@
   // Whether a runtime error occurred.
   bool error_;
   DISALLOW_COPY_AND_ASSIGN(ExecutionContext);
 };
 
 class NavigateOperation : public Operation {
  public:
   explicit NavigateOperation(const std::string& hashed_key)
       : hashed_key_(hashed_key) {}
   virtual ~NavigateOperation() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     const base::DictionaryValue* dict = NULL;
     if (!context->current_node()->GetAsDictionary(&dict)) {
       // Just ignore this node gracefully as this navigation is a dead end.
       // If this NavigateOperation occurred after a NavigateAny operation, those
       // may still be fulfillable, so we allow continuing the execution of the
       // sentence on other nodes.
       return true;
     }
     for (base::DictionaryValue::Iterator i(*dict); !i.IsAtEnd(); i.Advance()) {
       if (context->GetHash(i.key()) != hashed_key_)
         continue;
       context->stack()->push_back(&i.value());
       bool continue_traversal = context->ContinueExecution();
       context->stack()->pop_back();
       if (!continue_traversal)
         return false;
     }
     return true;
   }
 
  private:
   std::string hashed_key_;
   DISALLOW_COPY_AND_ASSIGN(NavigateOperation);
 };
 
 class NavigateAnyOperation : public Operation {
  public:
   NavigateAnyOperation() {}
   virtual ~NavigateAnyOperation() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     const base::DictionaryValue* dict = NULL;
     const base::ListValue* list = NULL;
     if (context->current_node()->GetAsDictionary(&dict)) {
       for (base::DictionaryValue::Iterator i(*dict);
            !i.IsAtEnd(); i.Advance()) {
         context->stack()->push_back(&i.value());
         bool continue_traversal = context->ContinueExecution();
         context->stack()->pop_back();
         if (!continue_traversal)
           return false;
@@ skipping 14 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NavigateAnyOperation);
 };
 
 class NavigateBackOperation : public Operation {
  public:
   NavigateBackOperation() {}
   virtual ~NavigateBackOperation() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     const base::Value* current_node = context->current_node();
     context->stack()->pop_back();
     bool continue_traversal = context->ContinueExecution();
     context->stack()->push_back(current_node);
     return continue_traversal;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NavigateBackOperation);
 };
 
 class StoreValue : public Operation {
  public:
   StoreValue(const std::string& hashed_name, scoped_ptr<base::Value> value)
       : hashed_name_(hashed_name),
         value_(value.Pass()) {
     DCHECK(base::IsStringUTF8(hashed_name));
     DCHECK(value_);
   }
   virtual ~StoreValue() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     context->working_memory()->Set(hashed_name_, value_->DeepCopy());
     return context->ContinueExecution();
   }
 
  private:
   std::string hashed_name_;
   scoped_ptr<base::Value> value_;
   DISALLOW_COPY_AND_ASSIGN(StoreValue);
 };
 
 class CompareStoredValue : public Operation {
  public:
   CompareStoredValue(const std::string& hashed_name,
                      scoped_ptr<base::Value> value,
                      scoped_ptr<base::Value> default_value)
       : hashed_name_(hashed_name),
         value_(value.Pass()),
         default_value_(default_value.Pass()) {
     DCHECK(base::IsStringUTF8(hashed_name));
     DCHECK(value_);
     DCHECK(default_value_);
   }
   virtual ~CompareStoredValue() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     const base::Value* actual_value = NULL;
     if (!context->working_memory()->Get(hashed_name_, &actual_value))
       actual_value = default_value_.get();
     if (!value_->Equals(actual_value))
       return true;
     return context->ContinueExecution();
   }
 
  private:
   std::string hashed_name_;
   scoped_ptr<base::Value> value_;
   scoped_ptr<base::Value> default_value_;
   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 {
+  virtual 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 10 matching lines @@
 // Stores the hash of the registerable domain name -- as in, the portion of the
 // domain that is registerable, as opposed to controlled by a registrar; without
 // subdomains -- of the URL represented by the current node into working memory.
 class StoreNodeRegisterableDomain : public Operation {
  public:
   explicit StoreNodeRegisterableDomain(const std::string& hashed_name)
       : hashed_name_(hashed_name) {
     DCHECK(base::IsStringUTF8(hashed_name));
   }
   virtual ~StoreNodeRegisterableDomain() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     std::string possibly_invalid_url;
     std::string domain;
     if (!context->current_node()->GetAsString(&possibly_invalid_url) ||
         !GetRegisterableDomain(possibly_invalid_url, &domain))
       return true;
     context->working_memory()->Set(
         hashed_name_, new base::StringValue(context->GetHash(domain)));
     return context->ContinueExecution();
   }
 
@@ skipping 28 matching lines @@
   }
 
   std::string hashed_name_;
   DISALLOW_COPY_AND_ASSIGN(StoreNodeRegisterableDomain);
 };
 
 class CompareNodeBool : public Operation {
  public:
   explicit CompareNodeBool(bool value) : value_(value) {}
   virtual ~CompareNodeBool() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     bool actual_value = false;
     if (!context->current_node()->GetAsBoolean(&actual_value))
       return true;
     if (actual_value != value_)
       return true;
     return context->ContinueExecution();
   }
 
  private:
   bool value_;
   DISALLOW_COPY_AND_ASSIGN(CompareNodeBool);
 };
 
 class CompareNodeHash : public Operation {
  public:
   explicit CompareNodeHash(const std::string& hashed_value)
       : hashed_value_(hashed_value) {}
   virtual ~CompareNodeHash() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     std::string actual_hash;
     if (!context->GetValueHash(*context->current_node(), &actual_hash) ||
         actual_hash != hashed_value_)
       return true;
     return context->ContinueExecution();
   }
 
  private:
   std::string hashed_value_;
   DISALLOW_COPY_AND_ASSIGN(CompareNodeHash);
 };
 
 class CompareNodeHashNot : public Operation {
  public:
   explicit CompareNodeHashNot(const std::string& hashed_value)
       : hashed_value_(hashed_value) {}
   virtual ~CompareNodeHashNot() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     std::string actual_hash;
     if (context->GetValueHash(*context->current_node(), &actual_hash) &&
         actual_hash == hashed_value_)
       return true;
     return context->ContinueExecution();
   }
 
  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 {
+  virtual 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 14 matching lines @@
  public:
   explicit CompareNodeSubstring(const std::string& hashed_pattern,
                                 size_t pattern_length,
                                 uint32 pattern_sum)
       : hashed_pattern_(hashed_pattern),
         pattern_length_(pattern_length),
         pattern_sum_(pattern_sum) {
     DCHECK(pattern_length_);
   }
   virtual ~CompareNodeSubstring() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     std::string value_as_string;
     if (!context->current_node()->GetAsString(&value_as_string) ||
         !pattern_length_ || value_as_string.size() < pattern_length_)
       return true;
     // Go over the string with a sliding window. Meanwhile, maintain the sum in
     // an incremental fashion, and only calculate the SHA-256 hash when the sum
     // checks out so as to improve performance.
     std::string::const_iterator window_begin = value_as_string.begin();
     std::string::const_iterator window_end = window_begin + pattern_length_ - 1;
     uint32 window_sum =
@@ skipping 12 matching lines @@
   std::string hashed_pattern_;
   size_t pattern_length_;
   uint32 pattern_sum_;
   DISALLOW_COPY_AND_ASSIGN(CompareNodeSubstring);
 };
 
 class StopExecutingSentenceOperation : public Operation {
  public:
   StopExecutingSentenceOperation() {}
   virtual ~StopExecutingSentenceOperation() {}
-  virtual bool Execute(ExecutionContext* context) OVERRIDE {
+  virtual bool Execute(ExecutionContext* context) override {
     return false;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StopExecutingSentenceOperation);
 };
 
 class Parser {
  public:
   explicit Parser(const std::string& program)
@@ skipping 274 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]);
 }