sync: Populate debug counters for directory types

sync/engine/directory_commit_contribution.cc

 // Copyright 2014 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 "sync/engine/directory_commit_contribution.h"
 
 #include "sync/engine/commit_util.h"
 #include "sync/engine/get_commit_ids.h"
 #include "sync/engine/syncer_util.h"
+#include "sync/internal_api/public/sessions/commit_counters.h"
 #include "sync/syncable/model_neutral_mutable_entry.h"
 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
 
 namespace syncer {
 
 using syncable::GET_BY_HANDLE;
 using syncable::SYNCER;
 
 DirectoryCommitContribution::~DirectoryCommitContribution() {
   DCHECK(!syncing_bits_set_);
@@ skipping 39 matching lines @@
 void DirectoryCommitContribution::AddToCommitMessage(
     sync_pb::ClientToServerMessage* msg) {
   DCHECK(syncing_bits_set_);
   sync_pb::CommitMessage* commit_message = msg->mutable_commit();
   entries_start_index_ = commit_message->entries_size();
   std::copy(entities_.begin(),
             entities_.end(),
             RepeatedPtrFieldBackInserter(commit_message->mutable_entries()));
   if (!context_.context().empty())
     commit_message->add_client_contexts()->Swap(&context_);
+
+  CommitCounters* counters = debug_info_emitter_->GetMutableCommitCounters();
+  counters->num_commits_attempted += entities_.size();
 }
 
 SyncerError DirectoryCommitContribution::ProcessCommitResponse(
     const sync_pb::ClientToServerResponse& response,
     sessions::StatusController* status) {
   DCHECK(syncing_bits_set_);
   const sync_pb::CommitResponse& commit_response = response.commit();
 
   int transient_error_commits = 0;
   int conflicting_commits = 0;
@@ skipping 34 matching lines @@
         case sync_pb::CommitResponse::TRANSIENT_ERROR:
           ++transient_error_commits;
           break;
         default:
           LOG(FATAL) << "Bad return from ProcessSingleCommitResponse";
       }
     }
     MarkDeletedChildrenSynced(dir_, &trans, &deleted_folders);
   }
 
+  CommitCounters* counters = debug_info_emitter_->GetMutableCommitCounters();
+  counters->num_commits_success += successes;
+  counters->num_commits_conflict += transient_error_commits;
+  counters->num_commits_error += transient_error_commits;
+
   int commit_count = static_cast<int>(metahandles_.size());
   if (commit_count == successes) {
     return SYNCER_OK;
   } else if (error_commits > 0) {
     return SERVER_RETURN_UNKNOWN_ERROR;
   } else if (transient_error_commits > 0) {
     return SERVER_RETURN_TRANSIENT_ERROR;
   } else if (conflicting_commits > 0) {
     // This means that the server already has an item with this version, but
     // we haven't seen that update yet.
     //
     // A well-behaved client should respond to this by proceeding to the
     // download updates phase, fetching the conflicting items, then attempting
     // to resolve the conflict.  That's not what this client does.
     //
     // We don't currently have any code to support that exceptional control
     // flow.  Instead, we abort the current sync cycle and start a new one.  The
     // end result is the same.
     return SERVER_RETURN_CONFLICT;
   } else {
     LOG(FATAL) << "Inconsistent counts when processing commit response";
     return SYNCER_OK;
   }
 }
 
 void DirectoryCommitContribution::CleanUp() {
   DCHECK(syncing_bits_set_);
   UnsetSyncingBits();
+  debug_info_emitter_->EmitCommitCountersUpdate();
 }
 
 size_t DirectoryCommitContribution::GetNumEntries() const {
   return metahandles_.size();
 }
 
 DirectoryCommitContribution::DirectoryCommitContribution(
     const std::vector<int64>& metahandles,
     const google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>& entities,
     const sync_pb::DataTypeContext& context,
@@ skipping 11 matching lines @@
   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
   for (std::vector<int64>::const_iterator it = metahandles_.begin();
        it != metahandles_.end(); ++it) {
     syncable::ModelNeutralMutableEntry entry(&trans, GET_BY_HANDLE, *it);
     entry.PutSyncing(false);
   }
   syncing_bits_set_ = false;
 }
 
 }  // namespace syncer