Cleanup histogram syncronizer a bit...

chrome/browser/metrics/histogram_synchronizer.cc

 // Copyright (c) 2009 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/metrics/histogram_synchronizer.h"
 
 #include "base/metrics/histogram.h"
 #include "base/logging.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/render_messages.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 HistogramSynchronizer::HistogramSynchronizer()
   : lock_(),
     received_all_renderer_histograms_(&lock_),
     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;
 }
 
 HistogramSynchronizer::~HistogramSynchronizer() {
   // Clean up.
   delete callback_task_;
   callback_task_ = NULL;
   callback_thread_ = NULL;
@@ skipping 10 matching lines @@
     TimeDelta wait_time) {
   DCHECK(MessageLoop::current()->type() == MessageLoop::TYPE_UI);
 
   int sequence_number = GetNextAvailableSequenceNumber(SYNCHRONOUS_HISTOGRAMS);
   for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
        !it.IsAtEnd(); it.Advance()) {
     IncrementPendingRenderers(SYNCHRONOUS_HISTOGRAMS);
     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);
     }
     unresponsive_renderer_count = synchronous_renderers_pending_;
     synchronous_renderers_pending_ = 0;
     synchronous_sequence_number_ = 0;
   }
   UMA_HISTOGRAM_COUNTS("Histogram.RendersNotRespondingSynchronous",
                        unresponsive_renderer_count);
   if (!unresponsive_renderer_count)
@@ skipping 30 matching lines @@
 
   // Tell all renderer processes to send their histograms.
   int sequence_number =
       current_synchronizer->GetNextAvailableSequenceNumber(ASYNC_HISTOGRAMS);
   for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
        !it.IsAtEnd(); it.Advance()) {
     current_synchronizer->IncrementPendingRenderers(ASYNC_HISTOGRAMS);
     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(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           current_synchronizer,
           &HistogramSynchronizer::ForceHistogramSynchronizationDoneCallback,
           sequence_number),
       wait_time);
 }
 
 // static
 void HistogramSynchronizer::DeserializeHistogramList(
     int sequence_number,
     const std::vector<std::string>& histograms) {
   HistogramSynchronizer* current_synchronizer =
       HistogramSynchronizer::CurrentSynchronizer();
   if (current_synchronizer == NULL)
     return;
 
   DCHECK(current_synchronizer->IsOnIoThread());
 
   for (std::vector<std::string>::const_iterator it = histograms.begin();
        it < histograms.end();
        ++it) {
     base::Histogram::DeserializeHistogramInfo(*it);
   }
 
   // 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;
     DCHECK(callback_task_ != NULL);
     CallCallbackTaskAndResetData();
     return true;
   }
 
   {
     AutoLock auto_lock(lock_);
@@ skipping 77 matching lines @@
   AutoLock auto_lock(lock_);
   ++next_available_sequence_number_;
   if (0 > next_available_sequence_number_) {
     // We wrapped around.
     next_available_sequence_number_ =
         chrome::kHistogramSynchronizerReservedSequenceNumber + 1;
   }
   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_;
   }
 }
 
 bool HistogramSynchronizer::IsOnIoThread() {
   if (io_message_loop_ == NULL) {
     io_message_loop_ = MessageLoop::current();
   }
   return (MessageLoop::current() == io_message_loop_);
 }
 
 // static
 HistogramSynchronizer* HistogramSynchronizer::histogram_synchronizer_ = NULL;