[Sync] Remove now-obsolete FastDump class

chrome/browser/sync/syncable/syncable.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 "chrome/browser/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 33 matching lines @@
 #include "chrome/browser/sync/protocol/preference_specifics.pb.h"
 #include "chrome/browser/sync/protocol/service_constants.h"
 #include "chrome/browser/sync/protocol/theme_specifics.pb.h"
 #include "chrome/browser/sync/protocol/typed_url_specifics.pb.h"
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable_changes_version.h"
 #include "chrome/browser/sync/syncable/syncable_columns.h"
 #include "chrome/browser/sync/util/crypto_helpers.h"
-#include "chrome/browser/sync/util/fast_dump.h"
 #include "chrome/common/deprecated/event_sys-inl.h"
 #include "net/base/escape.h"
 
 namespace {
 enum InvariantCheckLevel {
   OFF = 0,
   VERIFY_IN_MEMORY = 1,
   FULL_DB_VERIFICATION = 2
 };
 
 static const InvariantCheckLevel kInvariantCheckLevel = VERIFY_IN_MEMORY;
 
 // Max number of milliseconds to spend checking syncable entry invariants
 static const int kInvariantCheckMaxMs = 50;
 }  // namespace
 
-using browser_sync::FastDump;
 using browser_sync::SyncerUtil;
 using std::string;
 
 
 namespace syncable {
 
 int64 Now() {
 #if defined(OS_WIN)
   FILETIME filetime;
   SYSTEMTIME systime;
@@ skipping 1585 matching lines @@
 }
 
 // This function sets only the flags needed to get this entry to sync.
 void MarkForSyncing(syncable::MutableEntry* e) {
   DCHECK_NE(static_cast<MutableEntry*>(NULL), e);
   DCHECK(!e->IsRoot()) << "We shouldn't mark a permanent object for syncing.";
   e->Put(IS_UNSYNCED, true);
   e->Put(SYNCING, false);
 }
 
-}  // namespace syncable
-
-namespace {
-  class DumpSeparator {
-  } separator;
-  class DumpColon {
-  } colon;
-
-inline FastDump& operator<<(FastDump& dump, const DumpSeparator&) {
-  dump.out_->sputn(", ", 2);
-  return dump;
-}
-
-inline FastDump& operator<<(FastDump& dump, const DumpColon&) {
-  dump.out_->sputn(": ", 2);
-  return dump;
-}
-}  // namespace
-
-namespace syncable {
-
-std::ostream& operator<<(std::ostream& stream, const Entry& entry) {
-  // Using ostreams directly here is dreadfully slow, because a mutex is
-  // acquired for every <<.  Users noticed it spiking CPU.
-
+std::ostream& operator<<(std::ostream& os, const Entry& entry) {
   int i;
-  FastDump s(&stream);
   EntryKernel* const kernel = entry.kernel_;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
-    s << g_metas_columns[i].name << colon
-      << kernel->ref(static_cast<Int64Field>(i)) << separator;
+    os << g_metas_columns[i].name << ": "
+       << kernel->ref(static_cast<Int64Field>(i)) << ", ";
   }
   for ( ; i < ID_FIELDS_END; ++i) {
-    s << g_metas_columns[i].name << colon
-      << kernel->ref(static_cast<IdField>(i)) << separator;
+    os << g_metas_columns[i].name << ": "
+       << kernel->ref(static_cast<IdField>(i)) << ", ";
   }
-  s << "Flags: ";
+  os << "Flags: ";
   for ( ; i < BIT_FIELDS_END; ++i) {
     if (kernel->ref(static_cast<BitField>(i)))
-      s << g_metas_columns[i].name << separator;
+      os << g_metas_columns[i].name << ", ";
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     const string& field = kernel->ref(static_cast<StringField>(i));
-    s << g_metas_columns[i].name << colon << field << separator;
+    os << g_metas_columns[i].name << ": " << field << ", ";
   }
   for ( ; i < PROTO_FIELDS_END; ++i) {
-    s << g_metas_columns[i].name << colon
-      << EscapePath(
-          kernel->ref(static_cast<ProtoField>(i)).SerializeAsString())
-      << separator;
+    os << g_metas_columns[i].name << ": "
+       << EscapePath(
+           kernel->ref(static_cast<ProtoField>(i)).SerializeAsString())
+       << ", ";
   }
-  s << "TempFlags: ";
+  os << "TempFlags: ";
   for ( ; i < BIT_TEMPS_END; ++i) {
     if (kernel->ref(static_cast<BitTemp>(i)))
-      s << "#" << i - BIT_TEMPS_BEGIN << separator;
+      os << "#" << i - BIT_TEMPS_BEGIN << ", ";
   }
-  return stream;
+  return os;
 }
 
 std::ostream& operator<<(std::ostream& s, const Blob& blob) {
   for (Blob::const_iterator i = blob.begin(); i != blob.end(); ++i)
     s << std::hex << std::setw(2)
       << std::setfill('0') << static_cast<unsigned int>(*i);
   return s << std::dec;
 }
 
-FastDump& operator<<(FastDump& dump, const Blob& blob) {
-  if (blob.empty())
-    return dump;
-  string buffer(base::HexEncode(&blob[0], blob.size()));
-  dump.out_->sputn(buffer.c_str(), buffer.size());
-  return dump;
-}
-
 }  // namespace syncable