sync: Populate debug counters for directory types

sync/engine/directory_update_handler.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_update_handler.h"
 
 #include "sync/engine/conflict_resolver.h"
 #include "sync/engine/process_updates_util.h"
 #include "sync/engine/update_applicator.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
@@ skipping 42 matching lines @@
     // version is higher, it means a local change happened while the mutation
     // was in flight, and the local context takes priority.
     if (mutated_context.version() >= local_context.version() &&
         local_context.context() != mutated_context.context()) {
       dir_->SetDataTypeContext(&trans, type_, mutated_context);
       // TODO(zea): trigger the datatype's UpdateDataTypeContext method.
     } else if (mutated_context.version() < local_context.version()) {
       // A GetUpdates using the old context was in progress when the context was
       // set. Fail this get updates cycle, to force a retry.
       DVLOG(1) << "GU Context conflict detected, forcing GU retry.";
+      debug_info_emitter_->EmitUpdateCountersUpdate();
       return DATATYPE_TRIGGERED_RETRY;
     }
   }
 
   UpdateSyncEntities(&trans, applicable_updates, status);
 
   if (IsValidProgressMarker(progress_marker)) {
     ExpireEntriesIfNeeded(&trans, progress_marker);
     UpdateProgressMarker(progress_marker);
   }
+  debug_info_emitter_->EmitUpdateCountersUpdate();
   return SYNCER_OK;
 }
 
 void DirectoryUpdateHandler::ApplyUpdates(sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
   }
 
   // This will invoke handlers that belong to the model and its thread, so we
   // switch to the appropriate thread before we start this work.
   WorkCallback c = base::Bind(
       &DirectoryUpdateHandler::ApplyUpdatesImpl,
       // We wait until the callback is executed.  We can safely use Unretained.
       base::Unretained(this),
       base::Unretained(status));
   worker_->DoWorkAndWaitUntilDone(c);
+
+  debug_info_emitter_->EmitUpdateCountersUpdate();
 }
 
 void DirectoryUpdateHandler::PassiveApplyUpdates(
     sessions::StatusController* status) {
   if (!IsApplyUpdatesRequired()) {
     return;
   }
 
   // Just do the work here instead of deferring to another thread.
   ApplyUpdatesImpl(status);
+
+  debug_info_emitter_->EmitUpdateCountersUpdate();
 }
 
 SyncerError DirectoryUpdateHandler::ApplyUpdatesImpl(
     sessions::StatusController* status) {
   syncable::WriteTransaction trans(FROM_HERE, syncable::SYNCER, dir_);
 
   std::vector<int64> handles;
   dir_->GetUnappliedUpdateMetaHandles(
       &trans,
       FullModelTypeSet(type_),
       &handles);
 
   // First set of update application passes.
   UpdateApplicator applicator(dir_->GetCryptographer(&trans));
   applicator.AttemptApplications(&trans, handles);
+
+  // The old StatusController counters.
   status->increment_num_updates_applied_by(applicator.updates_applied());
   status->increment_num_hierarchy_conflicts_by(
       applicator.hierarchy_conflicts());
   status->increment_num_encryption_conflicts_by(
       applicator.encryption_conflicts());
 
+  // The new UpdateCounter counters.
+  UpdateCounters* counters = debug_info_emitter_->GetMutableUpdateCounters();
+  counters->num_updates_applied += applicator.updates_applied();
+  counters->num_hierarchy_conflict_application_failures =
+      applicator.hierarchy_conflicts();
+  counters->num_encryption_conflict_application_failures +=
+      applicator.encryption_conflicts();
+
   if (applicator.simple_conflict_ids().size() != 0) {
     // Resolve the simple conflicts we just detected.
     ConflictResolver resolver;
     resolver.ResolveConflicts(&trans,
                               dir_->GetCryptographer(&trans),
                               applicator.simple_conflict_ids(),
-                              status);
+                              status,
+                              counters);
 
     // Conflict resolution sometimes results in more updates to apply.
     handles.clear();
     dir_->GetUnappliedUpdateMetaHandles(
         &trans,
         FullModelTypeSet(type_),
         &handles);
 
     UpdateApplicator conflict_applicator(dir_->GetCryptographer(&trans));
     conflict_applicator.AttemptApplications(&trans, handles);
 
     // We count the number of updates from both applicator passes.
     status->increment_num_updates_applied_by(
         conflict_applicator.updates_applied());
+    counters->num_updates_applied += conflict_applicator.updates_applied();
 
     // Encryption conflicts should remain unchanged by the resolution of simple
     // conflicts.  Those can only be solved by updating our nigori key bag.
     DCHECK_EQ(conflict_applicator.encryption_conflicts(),
               applicator.encryption_conflicts());
 
     // Hierarchy conflicts should also remain unchanged, for reasons that are
     // more subtle.  Hierarchy conflicts exist when the application of a pending
     // update from the server would make the local folder hierarchy
     // inconsistent.  The resolution of simple conflicts could never affect the
@@ skipping 19 matching lines @@
     return false;  // We don't process control types here.
   }
 
   return dir_->TypeHasUnappliedUpdates(type_);
 }
 
 void DirectoryUpdateHandler::UpdateSyncEntities(
     syncable::ModelNeutralWriteTransaction* trans,
     const SyncEntityList& applicable_updates,
     sessions::StatusController* status) {
-  ProcessDownloadedUpdates(dir_, trans, type_, applicable_updates, status);
+  UpdateCounters* counters = debug_info_emitter_->GetMutableUpdateCounters();
+  counters->num_updates_received += applicable_updates.size();
+  ProcessDownloadedUpdates(dir_, trans, type_,
+                           applicable_updates, status, counters);
 }
 
 bool DirectoryUpdateHandler::IsValidProgressMarker(
     const sync_pb::DataTypeProgressMarker& progress_marker) const {
   int field_number = progress_marker.data_type_id();
   ModelType model_type = GetModelTypeFromSpecificsFieldNumber(field_number);
   if (!IsRealDataType(model_type) || type_ != model_type) {
     NOTREACHED()
         << "Update handler of type " << ModelTypeToString(type_)
         << " asked to process progress marker with invalid type "
@@ skipping 38 matching lines @@
               new_gc_directive.version_watermark())) {
     ExpireEntriesByVersion(dir_, trans, type_,
                            new_gc_directive.version_watermark());
   }
 
   cached_gc_directive_.reset(
       new sync_pb::GarbageCollectionDirective(new_gc_directive));
 }
 
 }  // namespace syncer