Cleanup histogram syncronizer a bit...

chrome/browser/metrics/histogram_synchronizer.cc

Index: chrome/browser/metrics/histogram_synchronizer.cc
===================================================================
--- chrome/browser/metrics/histogram_synchronizer.cc	(revision 64486)
+++ chrome/browser/metrics/histogram_synchronizer.cc	(working copy)
@@ -22,11 +22,11 @@
     callback_task_(NULL),
     callback_thread_(NULL),
     io_message_loop_(NULL),
-    next_available_sequence_number_(0),
-    async_sequence_number_(0),
+    next_available_sequence_number_(-2),
+    async_sequence_number_(-2),
     async_renderers_pending_(0),
     async_callback_start_time_(TimeTicks::Now()),
-    synchronous_sequence_number_(0),
+    synchronous_sequence_number_(-2),
     synchronous_renderers_pending_(0) {
   DCHECK(histogram_synchronizer_ == NULL);
   histogram_synchronizer_ = this;
@@ -57,14 +57,15 @@
     it.GetCurrentValue()->Send(
         new ViewMsg_GetRendererHistograms(sequence_number));
   }
+  // Send notification that we're done sending messages to renderers.
+  DecrementPendingRenderers(sequence_number);
 
   TimeTicks start = TimeTicks::Now();
   TimeTicks end_time = start + wait_time;
   int unresponsive_renderer_count;
   {
     AutoLock auto_lock(lock_);
-    while (synchronous_renderers_pending_ > 0 &&
-           TimeTicks::Now() < end_time) {
+    while (synchronous_renderers_pending_ > 0 && TimeTicks::Now() < end_time) {
       wait_time = end_time - TimeTicks::Now();
       received_all_renderer_histograms_.TimedWait(wait_time);
     }
@@ -115,6 +116,8 @@
     it.GetCurrentValue()->Send(
         new ViewMsg_GetRendererHistograms(sequence_number));
   }
+  // Send notification that we're done sending messages to renderers.
+  current_synchronizer->DecrementPendingRenderers(sequence_number);
 
   // Post a task that would be called after waiting for wait_time.
   BrowserThread::PostDelayedTask(
@@ -144,13 +147,12 @@
   }
 
   // Record that we have received a histogram from renderer process.
-  current_synchronizer->RecordRendererHistogram(sequence_number);
+  current_synchronizer->DecrementPendingRenderers(sequence_number);
 }
 
-bool HistogramSynchronizer::RecordRendererHistogram(int sequence_number) {
-  DCHECK(IsOnIoThread());
-
+bool HistogramSynchronizer::DecrementPendingRenderers(int sequence_number) {
   if (sequence_number == async_sequence_number_) {
+    DCHECK(IsOnIoThread());
     if ((async_renderers_pending_ == 0) ||
         (--async_renderers_pending_ > 0))
       return false;
@@ -248,22 +250,26 @@
   DCHECK_NE(next_available_sequence_number_,
             chrome::kHistogramSynchronizerReservedSequenceNumber);
   if (requester == ASYNC_HISTOGRAMS) {
+    DCHECK(IsOnIoThread());
     async_sequence_number_ = next_available_sequence_number_;
-    async_renderers_pending_ = 0;
+    async_renderers_pending_ = 1;
   } else if (requester == SYNCHRONOUS_HISTOGRAMS) {
     synchronous_sequence_number_ = next_available_sequence_number_;
-    synchronous_renderers_pending_ = 0;
+    synchronous_renderers_pending_ = 1;
   }
   return next_available_sequence_number_;
 }
 
 void HistogramSynchronizer::IncrementPendingRenderers(
     RendererHistogramRequester requester) {
-  AutoLock auto_lock(lock_);
   if (requester == ASYNC_HISTOGRAMS) {
-    async_renderers_pending_++;
+    DCHECK(IsOnIoThread());
+    DCHECK_GT(async_renderers_pending_, 0);
+    ++async_renderers_pending_;
   } else {
-    synchronous_renderers_pending_++;
+    AutoLock auto_lock(lock_);
+    DCHECK_GT(synchronous_renderers_pending_, 0);
+    ++synchronous_renderers_pending_;
   }
 }