Move StringPiece into the base namespace. It is colliding

net/base/registry_controlled_domain.h

 //* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 209 matching lines @@
   friend struct DefaultSingletonTraits<RegistryControlledDomainService>;
 
   void Init();
 
   // A DomainEntry is a combination of the domain name (as a StringPiece, so
   // that we can reference external memory without copying), and two bits of
   // information, if it's an exception and/or wildcard entry.  Note: we don't
   // consider the attributes when doing comparisons, so as far as any data
   // structures our concerned (ex our set), two DomainEntry's are equal as long
   // as their StringPiece (the domain) is equal.  This is the behavior we want.
-  class DomainEntry : public StringPiece {
+  class DomainEntry : public base::StringPiece {
    public:
     struct DomainEntryAttributes {
       DomainEntryAttributes() : exception(false), wildcard(false) { }
       ~DomainEntryAttributes() { }
 
       void Combine(const DomainEntryAttributes& other) {
         if (other.exception) exception = true;
         if (other.wildcard) wildcard = true;
       }
 
       bool exception;
       bool wildcard;
     };
 
-    DomainEntry() : StringPiece() { }
-    DomainEntry(const char* ptr, size_type size) : StringPiece(ptr, size) { }
+    DomainEntry() : base::StringPiece() { }
+    DomainEntry(const char* ptr, size_type size)
+        : base::StringPiece(ptr, size) { }
     ~DomainEntry() { }
 
     // We override StringPiece's operator < to make it more efficent, since we
     // don't care that it's sorted lexigraphically and we want to ignore the
     // attributes when we are doing the comparisons.
     bool operator<(const DomainEntry& other) const {
       // If we are the same size, call up to StringPiece's real less than.
       if (size() == other.size())
-        return *static_cast<const StringPiece*>(this) < other;
+        return *static_cast<const base::StringPiece*>(this) < other;
       // Consider ourselves less if we are smaller
       return size() < other.size();
     }
 
     DomainEntryAttributes attributes;
   };
 
   // An entry in the set of domain specifications, describing the properties
   // that apply to that domain rule.
   typedef std::set<DomainEntry> DomainSet;
 
   // Parses a list of effective-TLD rules, building the domain_set_.  Rules are
   // assumed to be syntactically valid.  We operate on a StringPiece.  If we
   // were populated from an embedded resource, we will reference the embedded
   // resource directly.  If we were populated through UseDomainData, then our
   // StringPiece will reference our local copy in copied_domain_data_.
-  void ParseDomainData(const StringPiece& data);
+  void ParseDomainData(const base::StringPiece& data);
 
   // Returns the singleton instance, after attempting to initialize it.
   // NOTE that if the effective-TLD data resource can't be found, the instance
   // will be initialized and continue operation with simple default TLD data.
   static RegistryControlledDomainService* GetInstance();
 
   // Adds one rule, assumed to be valid, to the domain_set_.
-  void AddRule(const StringPiece& rule_str);
+  void AddRule(const base::StringPiece& rule_str);
 
   // Internal workings of the static public methods.  See above.
   static std::string GetDomainAndRegistryImpl(const std::string& host);
   size_t GetRegistryLengthImpl(const std::string& host,
                                bool allow_unknown_registries);
 
   // A set of our DomainEntry's.
   DomainSet domain_set_;
 
   // An optional copy of the full domain rule data.  If we're loaded from a
   // resource, then we just reference the resource directly without copying,
   // and copied_domain_data_ is not used.  If we are populated through
   // UseDomainData() then we copy that data here and reference it.
   std::string copied_domain_data_;
 
   // The actual domain data that we parse on startup.
   static const char kDomainData[];
 
   DISALLOW_COPY_AND_ASSIGN(RegistryControlledDomainService);
 };
 
 }  // namespace net
 
 #endif  // NET_BASE_REGISTRY_CONTROLLED_DOMAIN_H_