[Sync] Clean up sync logging

chrome/browser/sync/engine/syncapi.cc

 // Copyright (c) 2011 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/engine/syncapi.h"
 
 #include <algorithm>
 #include <bitset>
 #include <iomanip>
 #include <list>
 #include <map>
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
+#include "base/compiler_specific.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/observer_list.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
@@ skipping 442 matching lines @@
 
   if (unencrypted->has_encrypted()) {
     // This specifics is already encrypted, our work is done.
     LOG(WARNING) << "Attempted to encrypt an already encrypted entity"
       << " specifics of type " << syncable::ModelTypeToString(type)
       << ". Dropping.";
     return;
   }
   sync_pb::EntitySpecifics encrypted;
   syncable::AddDefaultExtensionValue(type, &encrypted);
-  VLOG(2) << "Encrypted specifics of type " << syncable::ModelTypeToString(type)
-          << " with content: " << unencrypted->SerializeAsString() << "\n";
+  if (VLOG_IS_ON(2)) {
+    std::string unencrypted_base64;
+    if (!base::Base64Encode(unencrypted->SerializeAsString(),
+                            &unencrypted_base64)) {
+      NOTREACHED();
+    }
+    VLOG(2) << "Encrypted specifics of type "
+            << syncable::ModelTypeToString(type)
+            << " with content: " << unencrypted_base64 << "\n";
+  }
   if (!GetTransaction()->GetCryptographer()->Encrypt(
       *unencrypted,
       encrypted.mutable_encrypted())) {
     LOG(ERROR) << "Could not encrypt data for node of type " <<
       syncable::ModelTypeToString(type);
     NOTREACHED();
   }
   unencrypted->CopyFrom(encrypted);
 }
 
@@ skipping 694 matching lines @@
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public sync_notifier::SyncNotifierObserver,
       public browser_sync::JsBackend,
       public browser_sync::JsEventRouter,
       public SyncEngineEventListener,
       public ServerConnectionEventListener,
       public syncable::DirectoryChangeListener {
   static const int kDefaultNudgeDelayMilliseconds;
   static const int kPreferencesNudgeDelayMilliseconds;
  public:
-  explicit SyncInternal(SyncManager* sync_manager)
-      : core_message_loop_(NULL),
+  SyncInternal(const std::string& name, SyncManager* sync_manager)
+      : name_(name),
+        core_message_loop_(NULL),
         parent_router_(NULL),
         sync_manager_(sync_manager),
         registrar_(NULL),
         initialized_(false),
         method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         js_directory_change_listener_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     // Pre-fill |notification_info_map_|.
     for (int i = syncable::FIRST_REAL_MODEL_TYPE;
          i < syncable::MODEL_TYPE_COUNT; ++i) {
@@ skipping 380 matching lines @@
 
   browser_sync::JsArgList GetNodeDetailsById(
       const browser_sync::JsArgList& args);
 
   browser_sync::JsArgList GetChildNodeIds(
       const browser_sync::JsArgList& args);
 
   browser_sync::JsArgList FindNodesContainingString(
       const browser_sync::JsArgList& args);
 
+  const std::string name_;
+
   // We couple the DirectoryManager and username together in a UserShare member
   // so we can return a handle to share_ to clients of the API for use when
   // constructing any transaction type.
   UserShare share_;
 
   MessageLoop* core_message_loop_;
 
   ObserverList<SyncManager::Observer> observers_;
 
   browser_sync::JsEventRouter* parent_router_;
@@ skipping 50 matching lines @@
 
   browser_sync::JsDirectoryChangeListener js_directory_change_listener_;
 
   JsMessageHandlerMap js_message_handlers_;
 };
 const int SyncManager::SyncInternal::kDefaultNudgeDelayMilliseconds = 200;
 const int SyncManager::SyncInternal::kPreferencesNudgeDelayMilliseconds = 2000;
 
 SyncManager::Observer::~Observer() {}
 
-SyncManager::SyncManager() {
-  data_ = new SyncInternal(this);
-}
+SyncManager::SyncManager(const std::string& name)
+    : data_(new SyncInternal(name, ALLOW_THIS_IN_INITIALIZER_LIST(this))) {}
 
 bool SyncManager::Init(const FilePath& database_location,
                        const char* sync_server_and_path,
                        int sync_server_port,
                        bool use_ssl,
                        HttpPostProviderFactory* post_factory,
                        ModelSafeWorkerRegistrar* registrar,
                        const char* user_agent,
                        const SyncCredentials& credentials,
                        sync_notifier::SyncNotifier* sync_notifier,
@@ skipping 147 matching lines @@
     std::vector<SyncEngineEventListener*> listeners;
     listeners.push_back(&allstatus_);
     listeners.push_back(this);
     SyncSessionContext* context = new SyncSessionContext(
         connection_manager_.get(),
         dir_manager(),
         model_safe_worker_registrar,
         listeners);
     context->set_account_name(credentials.email);
     // The SyncerThread takes ownership of |context|.
-    syncer_thread_.reset(new SyncerThread(context, new Syncer()));
+    syncer_thread_.reset(
+        new SyncerThread(name_, context, new Syncer()));
   }
 
   bool signed_in = SignIn(credentials);
 
   if (signed_in && syncer_thread()) {
     syncer_thread()->Start(
         browser_sync::SyncerThread::CONFIGURATION_MODE, NULL);
   }
 
   // Do this once the directory is opened.
@@ skipping 1177 matching lines @@
 void SyncManager::TriggerOnIncomingNotificationForTest(
     const syncable::ModelTypeBitSet& model_types) {
   syncable::ModelTypePayloadMap model_types_with_payloads =
       syncable::ModelTypePayloadMapFromBitSet(model_types,
           std::string());
 
   data_->OnIncomingNotification(model_types_with_payloads);
 }
 
 }  // namespace sync_api