sync: Expose DirectoryDebugInfoEmitters in engine

sync/sessions/model_type_registry.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/sessions/model_type_registry.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "sync/engine/directory_commit_contributor.h"
 #include "sync/engine/directory_update_handler.h"
@@ skipping 13 matching lines @@
     workers_map_.insert(
         std::make_pair(workers[i]->GetModelSafeGroup(), workers[i]));
   }
 }
 
 ModelTypeRegistry::~ModelTypeRegistry() {}
 
 void ModelTypeRegistry::SetEnabledDirectoryTypes(
     const ModelSafeRoutingInfo& routing_info) {
   // Remove all existing directory processors and delete them.
+  // The DebugInfoEmitters are not deleted, since we want to keep their counts

[tim (not reviewing), 2014/04/30 23:24:50]

I wouldn't use the term "not deleted" or "never deleted" (below); just note that
their lifetime is tied to the ModelTypeRegistry.

That said, I was imaginging we'd remove the emitter for disabled types.  I don't
think I'd expect the numbers on about:sync to include types that were disabled? 

[rlarocque, 2014/04/30 23:44:13]

I figured that including disabled types would be a good thing.  Otherwise, some
"strictly incrementing" counters might be decremented when we disable a type. 
For example, just because bookmarks sync is disabled now doesn't mean that we
didn't receive X updates for that type back when it was enabled.

Regardless, we can make the decision elsewhere.  The data reported back to the
UI thread and the WebUI will include type information and enabled state.  We can
filter out disabled types there if we want to.  Assuming we split this into
aggregated and per-type stats, we might make different decisions about whether
or not to include disabled types in each of those counters.

+  // in case the type is ever re-enabled.
   for (ModelTypeSet::Iterator it = enabled_directory_types_.First();
        it.Good(); it.Inc()) {
     size_t result1 = update_handler_map_.erase(it.Get());
     size_t result2 = commit_contributor_map_.erase(it.Get());
-    size_t result3 = directory_type_debug_info_emitter_map_.erase(it.Get());
     DCHECK_EQ(1U, result1);
     DCHECK_EQ(1U, result2);
-    DCHECK_EQ(1U, result3);
   }
 
   // Clear the old instances of directory update handlers and commit
   // contributors, deleting their contents in the processs.
   directory_update_handlers_.clear();
   directory_commit_contributors_.clear();
-  directory_type_debug_info_emitters_.clear();
 
   // Create new ones and add them to the appropriate containers.
   for (ModelSafeRoutingInfo::const_iterator routing_iter = routing_info.begin();
        routing_iter != routing_info.end(); ++routing_iter) {
     ModelType type = routing_iter->first;
     ModelSafeGroup group = routing_iter->second;
     std::map<ModelSafeGroup, scoped_refptr<ModelSafeWorker> >::iterator
         worker_it = workers_map_.find(group);
     DCHECK(worker_it != workers_map_.end());
     scoped_refptr<ModelSafeWorker> worker = worker_it->second;
 
-    DirectoryTypeDebugInfoEmitter* emitter =
-        new DirectoryTypeDebugInfoEmitter(directory_, type,
-                                          &type_debug_info_observers_);
+    // DebugInfoEmitters are never deleted.  Use existing one if we have it.
+    DirectoryTypeDebugInfoEmitter* emitter = NULL;
+    DirectoryTypeDebugInfoEmitterMap::iterator it =
+        directory_type_debug_info_emitter_map_.find(type);
+    if (it != directory_type_debug_info_emitter_map_.end()) {
+      emitter = it->second;
+    } else {
+      emitter = new DirectoryTypeDebugInfoEmitter(directory_, type,
+                                                  &type_debug_info_observers_);
+      directory_type_debug_info_emitter_map_.insert(
+          std::make_pair(type, emitter));
+      directory_type_debug_info_emitters_.push_back(emitter);
+    }
+
     DirectoryCommitContributor* committer =
-        new DirectoryCommitContributor(directory_, type);
+        new DirectoryCommitContributor(directory_, type, emitter);
     DirectoryUpdateHandler* updater =
-        new DirectoryUpdateHandler(directory_, type, worker);
+        new DirectoryUpdateHandler(directory_, type, worker, emitter);
 
     // These containers take ownership of their contents.
     directory_commit_contributors_.push_back(committer);
     directory_update_handlers_.push_back(updater);
-    directory_type_debug_info_emitters_.push_back(emitter);
 
     bool inserted1 =
         update_handler_map_.insert(std::make_pair(type, updater)).second;
     DCHECK(inserted1) << "Attempt to override existing type handler in map";
 
     bool inserted2 =
         commit_contributor_map_.insert(std::make_pair(type, committer)).second;
     DCHECK(inserted2) << "Attempt to override existing type handler in map";
-
-    bool inserted3 =
-        directory_type_debug_info_emitter_map_.insert(
-            std::make_pair(type, emitter)).second;
-    DCHECK(inserted3) << "Attempt to override existing type handler in map";
   }
 
   enabled_directory_types_ = GetRoutingInfoTypes(routing_info);
   DCHECK(Intersection(GetEnabledDirectoryTypes(),
                       GetEnabledNonBlockingTypes()).Empty());
 }
 
 void ModelTypeRegistry::InitializeNonBlockingType(
     ModelType type,
     scoped_refptr<base::SequencedTaskRunner> type_task_runner,
@@ skipping 73 matching lines @@
   ModelTypeSet enabled_off_thread_types;
   for (ScopedVector<NonBlockingTypeProcessorCore>::const_iterator it =
            non_blocking_type_processor_cores_.begin();
        it != non_blocking_type_processor_cores_.end(); ++it) {
     enabled_off_thread_types.Put((*it)->GetModelType());
   }
   return enabled_off_thread_types;
 }
 
 }  // namespace syncer