sync: Populate debug counters for directory types

sync/engine/conflict_resolver.h

 // 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.
 //
 // A class that watches the syncer and attempts to resolve any conflicts that
 // occur.
 
 #ifndef SYNC_ENGINE_CONFLICT_RESOLVER_H_
 #define SYNC_ENGINE_CONFLICT_RESOLVER_H_
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "sync/engine/syncer_types.h"
 
 namespace syncer {
 
 namespace syncable {
 class Id;
 class WriteTransaction;
 }  // namespace syncable
 
 class Cryptographer;
+struct UpdateCounters;
 
 namespace sessions {
 class StatusController;
 }  // namespace sessions
 
 class ConflictResolver {
   friend class SyncerTest;
   FRIEND_TEST_ALL_PREFIXES(SyncerTest,
                            ConflictResolverMergeOverwritesLocalEntry);
  public:
@@ skipping 10 matching lines @@
     CONFLICT_RESOLUTION_SIZE,
   };
 
   ConflictResolver();
   ~ConflictResolver();
   // Called by the syncer at the end of a update/commit cycle.
   // Returns true if the syncer should try to apply its updates again.
   void ResolveConflicts(syncable::WriteTransaction* trans,
                         const Cryptographer* cryptographer,
                         const std::set<syncable::Id>& simple_conflict_ids,
-                        sessions::StatusController* status);
+                        sessions::StatusController* status,
+                        UpdateCounters* counters);

[tim (not reviewing), 2014/05/12 17:33:53]

It's unfortunate to have two status-tracking parameters doing analogus work
adding complexity at all the callsites. There's a fair bit of this happening.
What's the roadmap to removing StatusController? If you can't replace it, you
should follow the StatusController pattern and have it update UC under the hood,
OR have UC update StatusController under the hood. (alternatively we could plumb
around an adapter that knows how to update both with an interface that is the
union of the two.)

[rlarocque, 2014/05/12 18:13:18]

The point of this effort is to replace the StatusController.  I can't do that
until the new counters are hooked up to about:sync, but it should happen soon.

Updating "under the hood" won't be a valid approach for much longer.  It's
currently handled by some explicit snapshot taking and sending calls made on the
sync thread during a sync cycle.  When update application and conflict
resolution is divorced from the sync cycle and moves to a different thread, the
logic to emit updates will need to move with it.

 
  private:
   void ProcessSimpleConflict(
       syncable::WriteTransaction* trans,
       const syncable::Id& id,
       const Cryptographer* cryptographer,
-      sessions::StatusController* status);
+      sessions::StatusController* status,
+      UpdateCounters* counters);
 
   DISALLOW_COPY_AND_ASSIGN(ConflictResolver);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_ENGINE_CONFLICT_RESOLVER_H_