chrome/browser/metrics/tracking_synchronizer.cc - platform/external/chromium_org - Git at Google

 // 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 "chrome/browser/metrics/tracking_synchronizer.h"

 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
 #include "chrome/browser/metrics/tracking_synchronizer_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/profiler_controller.h"
 #include "content/public/common/process_type.h"

 using base::TimeTicks;
 using content::BrowserThread;

 namespace {

 // Negative numbers are never used as sequence numbers.  We explicitly pick a
 // negative number that is "so negative" that even when we add one (as is done
 // when we generated the next sequence number) that it will still be negative.
 // We have code that handles wrapping around on an overflow into negative
 // territory.
 const int kNeverUsableSequenceNumber = -2;

 // This singleton instance should be started during the single threaded
 // portion of main(). It initializes globals to provide support for all future
 // calls. This object is created on the UI thread, and it is destroyed after
 // all the other threads have gone away. As a result, it is ok to call it
 // from the UI thread, or for about:profiler.
 static chrome_browser_metrics::TrackingSynchronizer* g_tracking_synchronizer =
     NULL;

 }  // anonymous namespace

 namespace chrome_browser_metrics {

 // The "RequestContext" structure describes an individual request received
 // from the UI. All methods are accessible on UI thread.
 class TrackingSynchronizer::RequestContext {
  public:
   // A map from sequence_number_ to the actual RequestContexts.
   typedef std::map<int, RequestContext*> RequestContextMap;

   RequestContext(
       const base::WeakPtr<TrackingSynchronizerObserver>& callback_object,
       int sequence_number)
       : callback_object_(callback_object),
         sequence_number_(sequence_number),
         received_process_group_count_(0),
         processes_pending_(0) {
   }
   ~RequestContext() {}

   void SetReceivedProcessGroupCount(bool done) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     received_process_group_count_ = done;
   }

   // Methods for book keeping of processes_pending_.
   void IncrementProcessesPending() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     ++processes_pending_;
   }

   void AddProcessesPending(int processes_pending) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     processes_pending_ += processes_pending;
   }

   void DecrementProcessesPending() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     --processes_pending_;
   }

   // Records that we are waiting for one less tracking data from a process for
   // the given sequence number. If |received_process_group_count_| and
   // |processes_pending_| are zero, then delete the current object by calling
   // Unregister.
   void DeleteIfAllDone() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

     if (processes_pending_ <= 0 && received_process_group_count_)
       RequestContext::Unregister(sequence_number_);
   }

   // Register |callback_object| in |outstanding_requests_| map for the given
   // |sequence_number|.
   static RequestContext* Register(
       int sequence_number,
       const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

     RequestContext* request = new RequestContext(
         callback_object, sequence_number);
     outstanding_requests_.Get()[sequence_number] = request;

     return request;
   }

   // Find the |RequestContext| in |outstanding_requests_| map for the given
   // |sequence_number|.
   static RequestContext* GetRequestContext(int sequence_number) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

     RequestContextMap::iterator it =
         outstanding_requests_.Get().find(sequence_number);
     if (it == outstanding_requests_.Get().end())
       return NULL;

     RequestContext* request = it->second;
     DCHECK_EQ(sequence_number, request->sequence_number_);
     return request;
   }

   // Delete the entry for the given |sequence_number| from
   // |outstanding_requests_| map. This method is called when all changes have
   // been acquired, or when the wait time expires (whichever is sooner).
   static void Unregister(int sequence_number) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

     RequestContextMap::iterator it =
         outstanding_requests_.Get().find(sequence_number);
     if (it == outstanding_requests_.Get().end())
       return;

     RequestContext* request = it->second;
     DCHECK_EQ(sequence_number, request->sequence_number_);
     bool received_process_group_count = request->received_process_group_count_;
     int unresponsive_processes = request->processes_pending_;

     if (request->callback_object_.get())
       request->callback_object_->FinishedReceivingProfilerData();

     delete request;
     outstanding_requests_.Get().erase(it);

     UMA_HISTOGRAM_BOOLEAN("Profiling.ReceivedProcessGroupCount",
                           received_process_group_count);
     UMA_HISTOGRAM_COUNTS("Profiling.PendingProcessNotResponding",
                          unresponsive_processes);
   }

   // Delete all the entries in |outstanding_requests_| map.
   static void OnShutdown() {
     // Just in case we have any pending tasks, clear them out.
     while (!outstanding_requests_.Get().empty()) {
       RequestContextMap::iterator it = outstanding_requests_.Get().begin();
       delete it->second;
       outstanding_requests_.Get().erase(it);
     }
   }

   // Requests are made to asynchronously send data to the |callback_object_|.
   base::WeakPtr<TrackingSynchronizerObserver> callback_object_;

   // The sequence number used by the most recent update request to contact all
   // processes.
   int sequence_number_;

   // Indicates if we have received all pending processes count.
   bool received_process_group_count_;

   // The number of pending processes (browser, all renderer processes and
   // browser child processes) that have not yet responded to requests.
   int processes_pending_;

   // Map of all outstanding RequestContexts, from sequence_number_ to
   // RequestContext.
   static base::LazyInstance<RequestContextMap>::Leaky outstanding_requests_;
 };

 // static
 base::LazyInstance
     <TrackingSynchronizer::RequestContext::RequestContextMap>::Leaky
         TrackingSynchronizer::RequestContext::outstanding_requests_ =
             LAZY_INSTANCE_INITIALIZER;

 // TrackingSynchronizer methods and members.

 TrackingSynchronizer::TrackingSynchronizer()
     : last_used_sequence_number_(kNeverUsableSequenceNumber) {
   DCHECK(!g_tracking_synchronizer);
   g_tracking_synchronizer = this;
   content::ProfilerController::GetInstance()->Register(this);
 }

 TrackingSynchronizer::~TrackingSynchronizer() {
   content::ProfilerController::GetInstance()->Unregister(this);

   // Just in case we have any pending tasks, clear them out.
   RequestContext::OnShutdown();

   g_tracking_synchronizer = NULL;
 }

 // static
 void TrackingSynchronizer::FetchProfilerDataAsynchronously(
     const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

   if (!g_tracking_synchronizer) {
     // System teardown is happening.
     return;
   }

   int sequence_number = g_tracking_synchronizer->RegisterAndNotifyAllProcesses(
       callback_object);

   // Post a task that would be called after waiting for wait_time.  This acts
   // as a watchdog, to cancel the requests for non-responsive processes.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&RequestContext::Unregister, sequence_number),
       base::TimeDelta::FromMinutes(1));
 }

 void TrackingSynchronizer::OnPendingProcesses(int sequence_number,
                                               int pending_processes,
                                               bool end) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
   if (!request)
     return;
   request->AddProcessesPending(pending_processes);
   request->SetReceivedProcessGroupCount(end);
   request->DeleteIfAllDone();
 }

 void TrackingSynchronizer::OnProfilerDataCollected(
     int sequence_number,
     const tracked_objects::ProcessDataSnapshot& profiler_data,
     int process_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DecrementPendingProcessesAndSendData(sequence_number, profiler_data,
                                        process_type);
 }

 int TrackingSynchronizer::RegisterAndNotifyAllProcesses(
     const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

   int sequence_number = GetNextAvailableSequenceNumber();

   RequestContext* request =
       RequestContext::Register(sequence_number, callback_object);

   // Increment pending process count for sending browser's profiler data.
   request->IncrementProcessesPending();

   // Get profiler data from renderer and browser child processes.
   content::ProfilerController::GetInstance()->GetProfilerData(sequence_number);

   // Send profiler_data from browser process.
   tracked_objects::ProcessDataSnapshot process_data;
   tracked_objects::ThreadData::Snapshot(false, &process_data);
   DecrementPendingProcessesAndSendData(sequence_number, process_data,
                                        content::PROCESS_TYPE_BROWSER);

   return sequence_number;
 }

 void TrackingSynchronizer::DecrementPendingProcessesAndSendData(
     int sequence_number,
     const tracked_objects::ProcessDataSnapshot& profiler_data,
     int process_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

   RequestContext* request = RequestContext::GetRequestContext(sequence_number);
   if (!request)
     return;

   if (request->callback_object_.get()) {
     request->callback_object_
         ->ReceivedProfilerData(profiler_data, process_type);
   }

   // Delete request if we have heard back from all child processes.
   request->DecrementProcessesPending();
   request->DeleteIfAllDone();
 }

 int TrackingSynchronizer::GetNextAvailableSequenceNumber() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

   ++last_used_sequence_number_;

   // Watch out for wrapping to a negative number.
   if (last_used_sequence_number_ < 0)
     last_used_sequence_number_ = 1;
   return last_used_sequence_number_;
 }

 }  // namespace chrome_browser_metrics
	// 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 "chrome/browser/metrics/tracking_synchronizer.h"

	#include "base/bind.h"
	#include "base/metrics/histogram.h"
	#include "base/threading/thread.h"
	#include "base/tracked_objects.h"
	#include "chrome/browser/metrics/tracking_synchronizer_observer.h"
	#include "content/public/browser/browser_thread.h"
	#include "content/public/browser/profiler_controller.h"
	#include "content/public/common/process_type.h"

	using base::TimeTicks;
	using content::BrowserThread;

	namespace {

	// Negative numbers are never used as sequence numbers. We explicitly pick a
	// negative number that is "so negative" that even when we add one (as is done
	// when we generated the next sequence number) that it will still be negative.
	// We have code that handles wrapping around on an overflow into negative
	// territory.
	const int kNeverUsableSequenceNumber = -2;

	// This singleton instance should be started during the single threaded
	// portion of main(). It initializes globals to provide support for all future
	// calls. This object is created on the UI thread, and it is destroyed after
	// all the other threads have gone away. As a result, it is ok to call it
	// from the UI thread, or for about:profiler.
	static chrome_browser_metrics::TrackingSynchronizer* g_tracking_synchronizer =
	NULL;

	} // anonymous namespace

	namespace chrome_browser_metrics {

	// The "RequestContext" structure describes an individual request received
	// from the UI. All methods are accessible on UI thread.
	class TrackingSynchronizer::RequestContext {
	public:
	// A map from sequence_number_ to the actual RequestContexts.
	typedef std::map<int, RequestContext*> RequestContextMap;

	RequestContext(
	const base::WeakPtr<TrackingSynchronizerObserver>& callback_object,
	int sequence_number)
	: callback_object_(callback_object),
	sequence_number_(sequence_number),
	received_process_group_count_(0),
	processes_pending_(0) {
	}
	~RequestContext() {}

	void SetReceivedProcessGroupCount(bool done) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
	received_process_group_count_ = done;
	}

	// Methods for book keeping of processes_pending_.
	void IncrementProcessesPending() {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
	++processes_pending_;
	}

	void AddProcessesPending(int processes_pending) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
	processes_pending_ += processes_pending;
	}

	void DecrementProcessesPending() {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
	--processes_pending_;
	}

	// Records that we are waiting for one less tracking data from a process for
	// the given sequence number. If \|received_process_group_count_\| and
	// \|processes_pending_\| are zero, then delete the current object by calling
	// Unregister.
	void DeleteIfAllDone() {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	if (processes_pending_ <= 0 && received_process_group_count_)
	RequestContext::Unregister(sequence_number_);
	}

	// Register \|callback_object\| in \|outstanding_requests_\| map for the given
	// \|sequence_number\|.
	static RequestContext* Register(
	int sequence_number,
	const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	RequestContext* request = new RequestContext(
	callback_object, sequence_number);
	outstanding_requests_.Get()[sequence_number] = request;

	return request;
	}

	// Find the \|RequestContext\| in \|outstanding_requests_\| map for the given
	// \|sequence_number\|.
	static RequestContext* GetRequestContext(int sequence_number) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	RequestContextMap::iterator it =
	outstanding_requests_.Get().find(sequence_number);
	if (it == outstanding_requests_.Get().end())
	return NULL;

	RequestContext* request = it->second;
	DCHECK_EQ(sequence_number, request->sequence_number_);
	return request;
	}

	// Delete the entry for the given \|sequence_number\| from
	// \|outstanding_requests_\| map. This method is called when all changes have
	// been acquired, or when the wait time expires (whichever is sooner).
	static void Unregister(int sequence_number) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	RequestContextMap::iterator it =
	outstanding_requests_.Get().find(sequence_number);
	if (it == outstanding_requests_.Get().end())
	return;

	RequestContext* request = it->second;
	DCHECK_EQ(sequence_number, request->sequence_number_);
	bool received_process_group_count = request->received_process_group_count_;
	int unresponsive_processes = request->processes_pending_;

	if (request->callback_object_.get())
	request->callback_object_->FinishedReceivingProfilerData();

	delete request;
	outstanding_requests_.Get().erase(it);

	UMA_HISTOGRAM_BOOLEAN("Profiling.ReceivedProcessGroupCount",
	received_process_group_count);
	UMA_HISTOGRAM_COUNTS("Profiling.PendingProcessNotResponding",
	unresponsive_processes);
	}

	// Delete all the entries in \|outstanding_requests_\| map.
	static void OnShutdown() {
	// Just in case we have any pending tasks, clear them out.
	while (!outstanding_requests_.Get().empty()) {
	RequestContextMap::iterator it = outstanding_requests_.Get().begin();
	delete it->second;
	outstanding_requests_.Get().erase(it);
	}
	}

	// Requests are made to asynchronously send data to the \|callback_object_\|.
	base::WeakPtr<TrackingSynchronizerObserver> callback_object_;

	// The sequence number used by the most recent update request to contact all
	// processes.
	int sequence_number_;

	// Indicates if we have received all pending processes count.
	bool received_process_group_count_;

	// The number of pending processes (browser, all renderer processes and
	// browser child processes) that have not yet responded to requests.
	int processes_pending_;

	// Map of all outstanding RequestContexts, from sequence_number_ to
	// RequestContext.
	static base::LazyInstance<RequestContextMap>::Leaky outstanding_requests_;
	};

	// static
	base::LazyInstance
	<TrackingSynchronizer::RequestContext::RequestContextMap>::Leaky
	TrackingSynchronizer::RequestContext::outstanding_requests_ =
	LAZY_INSTANCE_INITIALIZER;

	// TrackingSynchronizer methods and members.

	TrackingSynchronizer::TrackingSynchronizer()
	: last_used_sequence_number_(kNeverUsableSequenceNumber) {
	DCHECK(!g_tracking_synchronizer);
	g_tracking_synchronizer = this;
	content::ProfilerController::GetInstance()->Register(this);
	}

	TrackingSynchronizer::~TrackingSynchronizer() {
	content::ProfilerController::GetInstance()->Unregister(this);

	// Just in case we have any pending tasks, clear them out.
	RequestContext::OnShutdown();

	g_tracking_synchronizer = NULL;
	}

	// static
	void TrackingSynchronizer::FetchProfilerDataAsynchronously(
	const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	if (!g_tracking_synchronizer) {
	// System teardown is happening.
	return;
	}

	int sequence_number = g_tracking_synchronizer->RegisterAndNotifyAllProcesses(
	callback_object);

	// Post a task that would be called after waiting for wait_time. This acts
	// as a watchdog, to cancel the requests for non-responsive processes.
	BrowserThread::PostDelayedTask(
	BrowserThread::UI, FROM_HERE,
	base::Bind(&RequestContext::Unregister, sequence_number),
	base::TimeDelta::FromMinutes(1));
	}

	void TrackingSynchronizer::OnPendingProcesses(int sequence_number,
	int pending_processes,
	bool end) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	RequestContext* request = RequestContext::GetRequestContext(sequence_number);
	if (!request)
	return;
	request->AddProcessesPending(pending_processes);
	request->SetReceivedProcessGroupCount(end);
	request->DeleteIfAllDone();
	}

	void TrackingSynchronizer::OnProfilerDataCollected(
	int sequence_number,
	const tracked_objects::ProcessDataSnapshot& profiler_data,
	int process_type) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
	DecrementPendingProcessesAndSendData(sequence_number, profiler_data,
	process_type);
	}

	int TrackingSynchronizer::RegisterAndNotifyAllProcesses(
	const base::WeakPtr<TrackingSynchronizerObserver>& callback_object) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	int sequence_number = GetNextAvailableSequenceNumber();

	RequestContext* request =
	RequestContext::Register(sequence_number, callback_object);

	// Increment pending process count for sending browser's profiler data.
	request->IncrementProcessesPending();

	// Get profiler data from renderer and browser child processes.
	content::ProfilerController::GetInstance()->GetProfilerData(sequence_number);

	// Send profiler_data from browser process.
	tracked_objects::ProcessDataSnapshot process_data;
	tracked_objects::ThreadData::Snapshot(false, &process_data);
	DecrementPendingProcessesAndSendData(sequence_number, process_data,
	content::PROCESS_TYPE_BROWSER);

	return sequence_number;
	}

	void TrackingSynchronizer::DecrementPendingProcessesAndSendData(
	int sequence_number,
	const tracked_objects::ProcessDataSnapshot& profiler_data,
	int process_type) {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	RequestContext* request = RequestContext::GetRequestContext(sequence_number);
	if (!request)
	return;

	if (request->callback_object_.get()) {
	request->callback_object_
	->ReceivedProfilerData(profiler_data, process_type);
	}

	// Delete request if we have heard back from all child processes.
	request->DecrementProcessesPending();
	request->DeleteIfAllDone();
	}

	int TrackingSynchronizer::GetNextAvailableSequenceNumber() {
	DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

	++last_used_sequence_number_;

	// Watch out for wrapping to a negative number.
	if (last_used_sequence_number_ < 0)
	last_used_sequence_number_ = 1;
	return last_used_sequence_number_;
	}

	} // namespace chrome_browser_metrics