base: Get rid of 'using' declaration of StringAppendF.

courgette/adjustment_method_2.cc

 // Copyright (c) 2010 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 "courgette/adjustment_method.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 #include <map>
@@ skipping 184 matching lines @@
   void operator=(const LabelInfo*);  // Disallow assignment only.
   // Public compiler generated copy constructor is needed to constuct
   // std::pair<Label*, LabelInfo> so that fresh LabelInfos can be allocated
   // inside a std::map.
 };
 
 typedef std::vector<LabelInfo*> Trace;
 
 std::string ToString(const LabelInfo* info) {
   std::string s;
-  StringAppendF(&s, "%c%d", "pm"[info->is_model_], info->debug_index_);
+  base::StringAppendF(&s, "%c%d", "pm"[info->is_model_], info->debug_index_);
   if (info->label_->index_ != Label::kNoIndex)
-    StringAppendF(&s, " (%d)", info->label_->index_);
+    base::StringAppendF(&s, " (%d)", info->label_->index_);
 
-  StringAppendF(&s, " #%u", info->refs_);
+  base::StringAppendF(&s, " #%u", info->refs_);
   return s;
 }
 
 // LabelInfoMaker maps labels to their surrogate LabelInfo objects.
 class LabelInfoMaker {
  public:
   LabelInfoMaker() : debug_label_index_gen_(0) {}
 
   LabelInfo* MakeLabelInfo(Label* label, bool is_model, uint32 position) {
     LabelInfo& slot = label_infos_[label];
@@ skipping 204 matching lines @@
   // VS2005's implementation of std::set<T>::set() requires T to have a copy
   // constructor.
   //   DISALLOW_COPY_AND_ASSIGN(Shingle);
   void operator=(const Shingle&);  // Disallow assignment only.
 };
 
 std::string ToString(const Shingle* instance) {
   std::string s;
   const char* sep = "<";
   for (size_t i = 0; i < Shingle::kWidth; ++i) {
-    // StringAppendF(&s, "%s%x ", sep, instance.at(i)->label_->rva_);
+    // base::StringAppendF(&s, "%s%x ", sep, instance.at(i)->label_->rva_);
     s += sep;
     s += ToString(instance->at(i));
     sep = ", ";
   }
-  StringAppendF(&s, ">(%" PRIuS ")@{%" PRIuS "}", instance->exemplar_position_,
-                instance->position_count());
+  base::StringAppendF(&s, ">(%" PRIuS ")@{%" PRIuS "}",
+                      instance->exemplar_position_,
+                      instance->position_count());
   return s;
 }
 
 
 bool Shingle::InterningLess::operator()(
     const Shingle& a,
     const Shingle& b) const {
   for (size_t i = 0;  i < kWidth;  ++i) {
     LabelInfo* info_a = a.at(i);
     LabelInfo* info_b = b.at(i);
@@ skipping 65 matching lines @@
   Histogram program_histogram_;
   int model_coverage_;
   int program_coverage_;
 };
 
 std::string ToString(const ShinglePattern::Index* index) {
   std::string s;
   if (index == NULL) {
     s = "<null>";
   } else {
-    StringAppendF(&s, "<%d: ", index->variables_);
+    base::StringAppendF(&s, "<%d: ", index->variables_);
     const char* sep = "";
     for (size_t i = 0;  i < Shingle::kWidth;  ++i) {
       s += sep;
       sep = ", ";
       uint32 kind = index->kinds_[i];
       int offset = kind & ShinglePattern::kOffsetMask;
       if (kind & ShinglePattern::kVariable)
-        StringAppendF(&s, "V%d", offset);
+        base::StringAppendF(&s, "V%d", offset);
       else
-        StringAppendF(&s, "%d", index->assigned_indexes_[offset]);
+        base::StringAppendF(&s, "%d", index->assigned_indexes_[offset]);
      }
-    StringAppendF(&s, " %x", index->hash_);
+    base::StringAppendF(&s, " %x", index->hash_);
     s += ">";
   }
   return s;
 }
 
 std::string HistogramToString(const ShinglePattern::Histogram& histogram,
                               size_t snippet_max) {
   std::string s;
   size_t histogram_size = histogram.size();
   size_t snippet_size = 0;
   for (ShinglePattern::Histogram::const_iterator p = histogram.begin();
        p != histogram.end();
        ++p) {
     if (++snippet_size > snippet_max && snippet_size != histogram_size) {
       s += " ...";
       break;
     }
-    StringAppendF(&s, " %" PRIuS, p->count());
+    base::StringAppendF(&s, " %" PRIuS, p->count());
   }
   return s;
 }
 
 std::string HistogramToStringFull(const ShinglePattern::Histogram& histogram,
                                   const char* indent,
                                   size_t snippet_max) {
   std::string s;
 
   size_t histogram_size = histogram.size();
   size_t snippet_size = 0;
   for (ShinglePattern::Histogram::const_iterator p = histogram.begin();
        p != histogram.end();
        ++p) {
     s += indent;
     if (++snippet_size > snippet_max && snippet_size != histogram_size) {
       s += "...\n";
       break;
     }
-    StringAppendF(&s, "(%" PRIuS ") ", p->count());
+    base::StringAppendF(&s, "(%" PRIuS ") ", p->count());
     s += ToString(&(*p->instance()));
     s += "\n";
   }
   return s;
 }
 
 std::string ToString(const ShinglePattern* pattern, size_t snippet_max = 3) {
   std::string s;
   if (pattern == NULL) {
     s = "<null>";
   } else {
     s = "{";
     s += ToString(pattern->index_);
-    StringAppendF(&s, ";  %d(%d):",
-                  static_cast<int>(pattern->model_histogram_.size()),
-                  pattern->model_coverage_);
+    base::StringAppendF(&s, ";  %d(%d):",
+                        static_cast<int>(pattern->model_histogram_.size()),
+                        pattern->model_coverage_);
 
     s += HistogramToString(pattern->model_histogram_, snippet_max);
-    StringAppendF(&s, ";  %d(%d):",
-                  static_cast<int>(pattern->program_histogram_.size()),
-                  pattern->program_coverage_);
+    base::StringAppendF(&s, ";  %d(%d):",
+                        static_cast<int>(pattern->program_histogram_.size()),
+                        pattern->program_coverage_);
     s += HistogramToString(pattern->program_histogram_, snippet_max);
     s += "}";
   }
   return s;
 }
 
 std::string ShinglePatternToStringFull(const ShinglePattern* pattern,
                                        size_t max) {
   std::string s;
   s += ToString(pattern->index_);
   s += "\n";
   size_t model_size = pattern->model_histogram_.size();
   size_t program_size = pattern->program_histogram_.size();
-  StringAppendF(&s, "  model shingles %" PRIuS "\n", model_size);
+  base::StringAppendF(&s, "  model shingles %" PRIuS "\n", model_size);
   s += HistogramToStringFull(pattern->model_histogram_, "    ", max);
-  StringAppendF(&s, "  program shingles %" PRIuS "\n", program_size);
+  base::StringAppendF(&s, "  program shingles %" PRIuS "\n", program_size);
   s += HistogramToStringFull(pattern->program_histogram_, "    ", max);
   return s;
 }
 
 struct ShinglePatternIndexLess {
   bool operator()(const ShinglePattern::Index& a,
                   const ShinglePattern::Index& b) const {
     if (a.hash_ < b.hash_) return true;
     if (a.hash_ > b.hash_) return false;
 
@@ skipping 664 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace adjustment_method_2
 
 AdjustmentMethod* AdjustmentMethod::MakeShingleAdjustmentMethod() {
   return new adjustment_method_2::Adjuster();
 }
 
 }  // namespace courgette