[invalidations] Added table with registered objectsIds

chrome/browser/ui/webui/invalidations_message_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 "chrome/browser/ui/webui/invalidations_message_handler.h"
 
 #include "base/bind.h"
 #include "chrome/browser/invalidation/invalidation_logger.h"
 #include "chrome/browser/invalidation/invalidation_service.h"
 #include "chrome/browser/invalidation/invalidation_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/web_ui.h"
+#include "sync/notifier/invalidation_handler.h"
 
 namespace invalidation {
 class InvalidationLogger;
 }  // namespace invalidation
 
 namespace syncer {
 class ObjectIdInvalidationMap;
 }  // namespace syncer
 
 InvalidationsMessageHandler::InvalidationsMessageHandler()
-    : logger_(NULL), isRegistered(false) {}
+    : logger_(NULL), is_registered_(false) {}
 
 InvalidationsMessageHandler::~InvalidationsMessageHandler() {
   if (logger_)
-    logger_->UnregisterForDebug(this);
+    logger_->UnregisterObserver(this);
 }
 
 void InvalidationsMessageHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "doneLoading",
       base::Bind(&InvalidationsMessageHandler::UIReady,
                  base::Unretained(this)));
 }
 
 void InvalidationsMessageHandler::UIReady(const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
-  if (!isRegistered && profile) {
+  if (!is_registered_ && profile) {

[James Hawkins, 2014/02/13 00:54:47]

You can't rid of the need for this member variable by using (an added)
logger_->IsObserverRegistered(this).

The need for the private member variable seems off to me.  How many times is
UIReady called?  Should only be once per lifetime of this object.

[mferreria_g, 2014/02/13 01:05:52]

It actually isn't. UIReady is called every time the page is refreshed, because
it is called by the JS onDocumentLoad. So this flag was added here to prevent
the message handler from being reregistered. Also, this was done as not to
expose any more of the ObserverList implementation of InvalidationLogger.

     invalidation::InvalidationService* invalidation_service =
         invalidation::InvalidationServiceFactory::GetForProfile(profile);
     if (invalidation_service)
       logger_ = invalidation_service->GetInvalidationLogger();
     if (logger_) {
-      logger_->RegisterForDebug(this);
-      isRegistered = true;
+      logger_->RegisterObserver(this);
+      is_registered_ = true;
     }
   }
   UpdateContent(args);
 }
 
 void InvalidationsMessageHandler::UpdateContent(const base::ListValue* args) {
   if (logger_)
     logger_->EmitContent();
 }
 
 void InvalidationsMessageHandler::OnUnregistration(
-    const base::DictionaryValue& newRegistrationState) {}
+    const base::DictionaryValue& details) {}
 
 void InvalidationsMessageHandler::OnRegistration(
-    const base::DictionaryValue& newRegistrationState) {}
+    const base::DictionaryValue& details) {}
 
 void InvalidationsMessageHandler::OnStateChange(
-    const syncer::InvalidatorState& newState) {
-  std::string state(syncer::InvalidatorStateToString(newState));
+    const syncer::InvalidatorState& new_state) {
+  std::string state(syncer::InvalidatorStateToString(new_state));
   web_ui()->CallJavascriptFunction("chrome.invalidations.updateState",
                                    base::StringValue(state));
 }
 
 void InvalidationsMessageHandler::OnUpdateIds(
-    const base::DictionaryValue& newIds) {}
-
+    const std::string& handler_name,
+    const syncer::ObjectIdSet& ids_set) {
+  scoped_ptr<base::ListValue> list_of_objects = ObjectIdSetToList(ids_set);
+  web_ui()->CallJavascriptFunction("chrome.invalidations.updateIds",
+                                   base::StringValue(handler_name),
+                                   *list_of_objects);
+}
 void InvalidationsMessageHandler::OnDebugMessage(
     const base::DictionaryValue& details) {}
 
 void InvalidationsMessageHandler::OnInvalidation(
-    const syncer::ObjectIdInvalidationMap& newInvalidations) {
-  scoped_ptr<base::ListValue> invalidationsList = newInvalidations.ToValue();
+    const syncer::ObjectIdInvalidationMap& new_invalidations) {
+  scoped_ptr<base::ListValue> invalidations_list = new_invalidations.ToValue();
   web_ui()->CallJavascriptFunction("chrome.invalidations.logInvalidations",
-                                   *invalidationsList);
+                                   *invalidations_list);
 }
+
+scoped_ptr<base::ListValue> InvalidationsMessageHandler::ObjectIdSetToList(
+    const syncer::ObjectIdSet& ids_set) {
+  scoped_ptr<base::ListValue> list(new base::ListValue());
+
+  for (syncer::ObjectIdSet::iterator it = ids_set.begin(); it != ids_set.end();
+       ++it) {
+    scoped_ptr<base::DictionaryValue> dic(new base::DictionaryValue);
+    dic->SetString("name", it->name());
+    dic->SetInteger("source", it->source());
+    list->Append(dic.release());
+  }
+  return list.Pass();
+}