Add more debug logging in SyncFileSystem services

chrome/browser/sync_file_system/drive_file_sync_service.cc

 // Copyright (c) 2012 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_file_system/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 74 matching lines @@
     completion_callback_.Reset();
   }
 
   void UpdateTask(const tracked_objects::Location& location,
                   TaskType task_type,
                   const std::string& description) {
     location_ = location;
     task_type_ = task_type;
     description_ = description;
 
-    DVLOG(1) << "Token updated: " << description_
+    DVLOG(2) << "Token updated: " << description_
              << " " << location_.ToString();
   }
 
   const tracked_objects::Location& location() const { return location_; }
   TaskType task_type() const { return task_type_; }
   const std::string& description() const { return description_; }
   std::string done_description() const { return description_ + " done"; }
 
   void set_completion_callback(const base::Closure& callback) {
     completion_callback_ = callback;
@@ skipping 254 matching lines @@
   }
 
   const fileapi::FileSystemURL& url = pending_changes_.begin()->url;
   const GURL& origin = url.origin();
   const FilePath& path = url.path();
   DCHECK(ContainsKey(url_to_change_, origin));
   PathToChange* path_to_change = &url_to_change_[origin];
   DCHECK(ContainsKey(*path_to_change, path));
   const RemoteChange& remote_change = (*path_to_change)[path];
 
+  DVLOG(1) << "ProcessRemoteChange for " << url.DebugString()
+           << " remote_change:" << remote_change.change.DebugString();
+
   scoped_ptr<ProcessRemoteChangeParam> param(new ProcessRemoteChangeParam(
       token.Pass(), processor, remote_change, callback));
   processor->PrepareForProcessRemoteChange(
       remote_change.url,
       base::Bind(&DriveFileSyncService::DidPrepareForProcessRemoteChange,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 LocalChangeProcessor* DriveFileSyncService::GetLocalChangeProcessor() {
   return this;
@@ skipping 200 matching lines @@
   return token_.Pass();
 }
 
 void DriveFileSyncService::NotifyTaskDone(fileapi::SyncStatusCode status,
                                           scoped_ptr<TaskToken> token) {
   DCHECK(token);
   last_operation_status_ = status;
   token_ = token.Pass();
 
   if (token_->task_type() != TASK_TYPE_NONE) {
-    DVLOG(1) << "NotifyTaskDone: " << token_->description()
+    DVLOG(2) << "NotifyTaskDone: " << token_->description()
              << ": finished with status=" << status
+             << " (" << SyncStatusCodeToString(status) << ")"
              << " " << token_->location().ToString();
 
     RemoteServiceState old_state = state_;
     UpdateServiceState();
 
     // Notify remote sync service state if the state has been changed.
     if (!token_->description().empty() || old_state != state_) {
       FOR_EACH_OBSERVER(
           Observer, observers_,
           OnRemoteServiceStateUpdated(state_, token_->done_description()));
@@ skipping 808 matching lines @@
   }
 
   polling_enabled_ = false;
   token->set_completion_callback(base::Bind(&EnablePolling, &polling_enabled_));
 
   if (metadata_store_->incremental_sync_origins().empty()) {
     NotifyTaskDone(fileapi::SYNC_STATUS_OK, token.Pass());
     return;
   }
 
+  DVLOG(1) << "FetchChangesForIncrementalSync (start_changestamp:"
+           << (largest_fetched_changestamp_ + 1) << ")";
+
   sync_client_->ListChanges(
       largest_fetched_changestamp_ + 1,
       base::Bind(&DriveFileSyncService::DidFetchChangesForIncrementalSync,
                  AsWeakPtr(), base::Passed(&token)));
 }
 
 void DriveFileSyncService::DidFetchChangesForIncrementalSync(
     scoped_ptr<TaskToken> token,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::DocumentFeed> changes) {
   if (error != google_apis::HTTP_SUCCESS) {
     NotifyTaskDone(GDataErrorCodeToSyncStatusCodeWrapper(error), token.Pass());
     return;
   }
 
   typedef ScopedVector<google_apis::DocumentEntry>::const_iterator iterator;
   for (iterator itr = changes->entries().begin();
        itr != changes->entries().end(); ++itr) {
     const google_apis::DocumentEntry& entry = **itr;
+    DVLOG(3) << " change:" << entry.title();
     GURL origin;
     if (!GetOriginForEntry(entry, &origin))
       continue;
 
     AppendNewRemoteChange(origin, entry, entry.changestamp(),
                           REMOTE_SYNC_TYPE_INCREMENTAL);
   }
 
   GURL next_feed;
   if (changes->GetNextFeedURL(&next_feed)) {
@@ skipping 73 matching lines @@
 fileapi::SyncStatusCode
 DriveFileSyncService::GDataErrorCodeToSyncStatusCodeWrapper(
     google_apis::GDataErrorCode error) const {
   fileapi::SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != fileapi::SYNC_STATUS_OK && !sync_client_->IsAuthenticated())
     return fileapi::SYNC_STATUS_AUTHENTICATION_FAILED;
   return status;
 }
 
 }  // namespace sync_file_system