[invalidations] Added table with registered objectsIds

sync/notifier/non_blocking_invalidator.cc

 // 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.
 
 #include "sync/notifier/non_blocking_invalidator.h"
 
 #include <cstddef>
 
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 53 matching lines @@
       const NonBlockingInvalidator::InitializeOptions& initialize_options);
   void Teardown();
   void UpdateRegisteredIds(const ObjectIdSet& ids);
   void UpdateCredentials(const std::string& email, const std::string& token);
 
   // InvalidationHandler implementation (all called on I/O thread by
   // InvalidationNotifier).
   virtual void OnInvalidatorStateChange(InvalidatorState reason) OVERRIDE;
   virtual void OnIncomingInvalidation(
       const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
+  virtual std::string GetOwnerName() OVERRIDE;
 
  private:
   friend class
       base::RefCountedThreadSafe<NonBlockingInvalidator::Core>;
   // Called on parent or I/O thread.
   virtual ~Core();
 
   // The variables below should be used only on the I/O thread.
   const WeakHandle<InvalidationHandler> delegate_observer_;
   scoped_ptr<InvalidationNotifier> invalidation_notifier_;
@@ skipping 56 matching lines @@
 }
 
 void NonBlockingInvalidator::Core::OnIncomingInvalidation(
     const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
                           &InvalidationHandler::OnIncomingInvalidation,
                           invalidation_map);
 }
 
+std::string NonBlockingInvalidator::Core::GetOwnerName() { return "Sync"; }
+
 NonBlockingInvalidator::NonBlockingInvalidator(
     NetworkChannelCreator network_channel_creator,
     const std::string& invalidator_client_id,
     const UnackedInvalidationsMap& saved_invalidations,
     const std::string& invalidation_bootstrap_data,
     const WeakHandle<InvalidationStateTracker>&
         invalidation_state_tracker,
     const std::string& client_info,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter)
     : parent_task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ skipping 74 matching lines @@
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.UpdateInvalidatorState(state);
 }
 
 void NonBlockingInvalidator::OnIncomingInvalidation(
         const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 
+std::string NonBlockingInvalidator::GetOwnerName() { return "Sync"; }
+
 NetworkChannelCreator
     NonBlockingInvalidator::MakePushClientChannelCreator(
         const notifier::NotifierOptions& notifier_options) {
   return base::Bind(SyncNetworkChannel::CreatePushClientChannel,
       notifier_options);
 }
 
 NetworkChannelCreator NonBlockingInvalidator::MakeGCMNetworkChannelCreator(
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_ptr<GCMNetworkChannelDelegate> delegate) {
   return base::Bind(&SyncNetworkChannel::CreateGCMNetworkChannel,
                     request_context_getter,
                     base::Passed(&delegate));
 }
 
 }  // namespace syncer