1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_METRICS_TRACKING_SYNCHRONIZER_H_ 6 #define CHROME_BROWSER_METRICS_TRACKING_SYNCHRONIZER_H_ 7 8 #include <map> 9 #include <string> 10 #include <vector> 11 12 #include "base/basictypes.h" 13 #include "base/lazy_instance.h" 14 #include "base/memory/ref_counted.h" 15 #include "base/memory/weak_ptr.h" 16 #include "content/public/browser/profiler_subscriber.h" 17 18 // This class maintains state that is used to upload profiler data from the 19 // various processes, into the browser process. Such transactions are usually 20 // instigated by the browser. In general, a process will respond by gathering 21 // profiler data, and transmitting the pickled profiler data. We collect the 22 // data in asynchronous mode that doesn't block the UI thread. 23 // 24 // To assure that all the processes have responded, a counter is maintained 25 // to indicate the number of pending (not yet responsive) processes. We tag 26 // each group of requests with a sequence number. For each group of requests, we 27 // create RequestContext object which stores the sequence number, pending 28 // processes and the callback_object that needs to be notified when we receive 29 // an update from processes. When an update arrives we find the RequestContext 30 // associated with sequence number and send the unpickled profiler data to the 31 // |callback_object_|. 32 33 namespace chrome_browser_metrics { 34 35 class TrackingSynchronizerObserver; 36 37 class TrackingSynchronizer 38 : public content::ProfilerSubscriber, 39 public base::RefCountedThreadSafe<TrackingSynchronizer> { 40 public: 41 // Construction also sets up the global singleton instance. This instance is 42 // used to communicate between the IO and UI thread, and is destroyed only as 43 // the main thread (browser_main) terminates, which means the IO thread has 44 // already completed, and will not need this instance any further. 45 TrackingSynchronizer(); 46 47 // Contact all processes, and get them to upload to the browser any/all 48 // changes to profiler data. It calls |callback_object|'s SetData method with 49 // the data received from each sub-process. 50 // This method is accessible on UI thread. 51 static void FetchProfilerDataAsynchronously( 52 const base::WeakPtr<TrackingSynchronizerObserver>& callback_object); 53 54 // ------------------------------------------------------ 55 // ProfilerSubscriber methods for browser child processes 56 // ------------------------------------------------------ 57 58 // Update the number of pending processes for the given |sequence_number|. 59 // This is called on UI thread. 60 virtual void OnPendingProcesses(int sequence_number, 61 int pending_processes, 62 bool end) OVERRIDE; 63 64 private: 65 friend class base::RefCountedThreadSafe<TrackingSynchronizer>; 66 67 class RequestContext; 68 69 virtual ~TrackingSynchronizer(); 70 71 // Send profiler_data back to callback_object_ by calling 72 // DecrementPendingProcessesAndSendData which records that we are waiting 73 // for one less profiler data from renderer or browser child process for the 74 // given sequence number. This method is accessible on UI thread. 75 virtual void OnProfilerDataCollected( 76 int sequence_number, 77 const tracked_objects::ProcessDataSnapshot& profiler_data, 78 int process_type) OVERRIDE; 79 80 // Establish a new sequence_number_, and use it to notify all the processes of 81 // the need to supply, to the browser, their tracking data. It also registers 82 // |callback_object| in |outstanding_requests_| map. Return the 83 // sequence_number_ that was used. This method is accessible on UI thread. 84 int RegisterAndNotifyAllProcesses( 85 const base::WeakPtr<TrackingSynchronizerObserver>& callback_object); 86 87 // It finds the RequestContext for the given |sequence_number| and notifies 88 // the RequestContext's |callback_object_| about the |value|. This is called 89 // whenever we receive profiler data from processes. It also records that we 90 // are waiting for one less profiler data from a process for the given 91 // sequence number. If we have received a response from all renderers and 92 // browser processes, then it calls RequestContext's DeleteIfAllDone to delete 93 // the entry for sequence_number. This method is accessible on UI thread. 94 void DecrementPendingProcessesAndSendData( 95 int sequence_number, 96 const tracked_objects::ProcessDataSnapshot& profiler_data, 97 int process_type); 98 99 // Get a new sequence number to be sent to processes from browser process. 100 // This method is accessible on UI thread. 101 int GetNextAvailableSequenceNumber(); 102 103 // We don't track the actual processes that are contacted for an update, only 104 // the count of the number of processes, and we can sometimes time-out and 105 // give up on a "slow to respond" process. We use a sequence_number to be 106 // sure a response from a process is associated with the current round of 107 // requests. All sequence numbers used are non-negative. 108 // last_used_sequence_number_ is the most recently used number (used to avoid 109 // reuse for a long time). 110 int last_used_sequence_number_; 111 112 DISALLOW_COPY_AND_ASSIGN(TrackingSynchronizer); 113 }; 114 115 } // namespace chrome_browser_metrics 116 117 #endif // CHROME_BROWSER_METRICS_TRACKING_SYNCHRONIZER_H_ 118
