Move IsStringUTF8/ASCII to base namespace

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 177 matching lines @@
 
  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(IsStringUTF8(hashed_name));
+    DCHECK(base::IsStringUTF8(hashed_name));
     DCHECK(value_);
   }
   virtual ~StoreValue() {}
   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(IsStringUTF8(hashed_name));
+    DCHECK(base::IsStringUTF8(hashed_name));
     DCHECK(value_);
     DCHECK(default_value_);
   }
   virtual ~CompareStoredValue() {}
   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(IsStringUTF8(hashed_name));
+    DCHECK(base::IsStringUTF8(hashed_name));
   }
   virtual ~StoreNodeValue() {}
   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;
@@ skipping 10 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StoreNodeValue);
 };
 
 // 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(IsStringUTF8(hashed_name));
+    DCHECK(base::IsStringUTF8(hashed_name));
   }
   virtual ~StoreNodeRegisterableDomain() {}
   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)));
@@ skipping 192 matching lines @@
           break;
         }
         case jtl_foundation::NAVIGATE_ANY:
           operators.push_back(new NavigateAnyOperation);
           break;
         case jtl_foundation::NAVIGATE_BACK:
           operators.push_back(new NavigateBackOperation);
           break;
         case jtl_foundation::STORE_BOOL: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           bool value = false;
           if (!ReadBool(&value))
             return false;
           operators.push_back(new StoreValue(
               hashed_name,
               scoped_ptr<base::Value>(new base::FundamentalValue(value))));
           break;
         }
         case jtl_foundation::COMPARE_STORED_BOOL: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           bool value = false;
           if (!ReadBool(&value))
             return false;
           bool default_value = false;
           if (!ReadBool(&default_value))
             return false;
           operators.push_back(new CompareStoredValue(
               hashed_name,
               scoped_ptr<base::Value>(new base::FundamentalValue(value)),
               scoped_ptr<base::Value>(
                   new base::FundamentalValue(default_value))));
           break;
         }
         case jtl_foundation::STORE_HASH: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           std::string hashed_value;
           if (!ReadHash(&hashed_value))
             return false;
           operators.push_back(new StoreValue(
               hashed_name,
               scoped_ptr<base::Value>(new base::StringValue(hashed_value))));
           break;
         }
         case jtl_foundation::COMPARE_STORED_HASH: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           std::string hashed_value;
           if (!ReadHash(&hashed_value))
             return false;
           std::string hashed_default_value;
           if (!ReadHash(&hashed_default_value))
             return false;
           operators.push_back(new CompareStoredValue(
               hashed_name,
               scoped_ptr<base::Value>(new base::StringValue(hashed_value)),
               scoped_ptr<base::Value>(
                   new base::StringValue(hashed_default_value))));
           break;
         }
         case jtl_foundation::STORE_NODE_BOOL: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           operators.push_back(new StoreNodeValue<true>(hashed_name));
           break;
         }
         case jtl_foundation::STORE_NODE_HASH: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           operators.push_back(new StoreNodeValue<false>(hashed_name));
           break;
         }
         case jtl_foundation::STORE_NODE_REGISTERABLE_DOMAIN_HASH: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           operators.push_back(new StoreNodeRegisterableDomain(hashed_name));
           break;
         }
         case jtl_foundation::COMPARE_NODE_BOOL: {
           bool value = false;
           if (!ReadBool(&value))
             return false;
           operators.push_back(new CompareNodeBool(value));
           break;
         }
         case jtl_foundation::COMPARE_NODE_HASH: {
           std::string hashed_value;
           if (!ReadHash(&hashed_value))
             return false;
           operators.push_back(new CompareNodeHash(hashed_value));
           break;
         }
         case jtl_foundation::COMPARE_NODE_HASH_NOT: {
           std::string hashed_value;
           if (!ReadHash(&hashed_value))
             return false;
           operators.push_back(new CompareNodeHashNot(hashed_value));
           break;
         }
         case jtl_foundation::COMPARE_NODE_TO_STORED_BOOL: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           operators.push_back(new CompareNodeToStored<true>(hashed_name));
           break;
         }
         case jtl_foundation::COMPARE_NODE_TO_STORED_HASH: {
           std::string hashed_name;
-          if (!ReadHash(&hashed_name) || !IsStringUTF8(hashed_name))
+          if (!ReadHash(&hashed_name) || !base::IsStringUTF8(hashed_name))
             return false;
           operators.push_back(new CompareNodeToStored<false>(hashed_name));
           break;
         }
         case jtl_foundation::COMPARE_NODE_SUBSTRING: {
           std::string hashed_pattern;
           uint32 pattern_length = 0, pattern_sum = 0;
           if (!ReadHash(&hashed_pattern))
             return false;
           if (!ReadUint32(&pattern_length) || pattern_length == 0)
@@ skipping 130 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]);
 }