Home | History | Annotate | Download | only in browser 
      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_MEMORY_DETAILS_H_
      6 #define CHROME_BROWSER_MEMORY_DETAILS_H_
      7 
      8 #include <map>
      9 #include <vector>
     10 
     11 #include "base/memory/ref_counted.h"
     12 #include "base/process/process_handle.h"
     13 #include "base/process/process_metrics.h"
     14 #include "base/strings/string16.h"
     15 #include "base/time/time.h"
     16 #include "chrome/browser/site_details.h"
     17 #include "content/public/common/process_type.h"
     18 
     19 // We collect data about each browser process.  A browser may
     20 // have multiple processes (of course!).  Even IE has multiple
     21 // processes these days.
     22 struct ProcessMemoryInformation {
     23   // NOTE: Do not remove or reorder the elements in this enum, and only add new
     24   // items at the end. We depend on these specific values in a histogram.
     25   enum RendererProcessType {
     26     RENDERER_UNKNOWN = 0,
     27     RENDERER_NORMAL,
     28     RENDERER_CHROME,        // WebUI (chrome:// URL)
     29     RENDERER_EXTENSION,     // chrome-extension://
     30     RENDERER_DEVTOOLS,      // Web inspector
     31     RENDERER_INTERSTITIAL,  // malware/phishing interstitial
     32     RENDERER_BACKGROUND_APP // hosted app background page
     33   };
     34 
     35   static std::string GetRendererTypeNameInEnglish(RendererProcessType type);
     36   static std::string GetFullTypeNameInEnglish(
     37       int process_type,
     38       RendererProcessType rtype);
     39 
     40   ProcessMemoryInformation();
     41   ~ProcessMemoryInformation();
     42 
     43   // Default ordering is by private memory consumption.
     44   bool operator<(const ProcessMemoryInformation& rhs) const;
     45 
     46   // The process id.
     47   base::ProcessId pid;
     48   // The working set information.
     49   base::WorkingSetKBytes working_set;
     50   // The committed bytes.
     51   base::CommittedKBytes committed;
     52   // The process version
     53   base::string16 version;
     54   // The process product name.
     55   base::string16 product_name;
     56   // The number of processes which this memory represents.
     57   int num_processes;
     58   // A process is a diagnostics process if it is rendering about:memory.
     59   // Mark this specially so that it can avoid counting it in its own
     60   // results.
     61   bool is_diagnostics;
     62   // If this is a child process of Chrome, what type (i.e. plugin) it is.
     63   int process_type;
     64   // If this is a renderer process, what type it is.
     65   RendererProcessType renderer_type;
     66   // A collection of titles used, i.e. for a tab it'll show all the page titles.
     67   std::vector<base::string16> titles;
     68 };
     69 
     70 typedef std::vector<ProcessMemoryInformation> ProcessMemoryInformationList;
     71 
     72 // Browser Process Information.
     73 struct ProcessData {
     74   ProcessData();
     75   ProcessData(const ProcessData& rhs);
     76   ~ProcessData();
     77   ProcessData& operator=(const ProcessData& rhs);
     78 
     79   base::string16 name;
     80   base::string16 process_name;
     81   ProcessMemoryInformationList processes;
     82 
     83   // Track site data for predicting process counts with out-of-process iframes.
     84   // See site_details.h.
     85   BrowserContextSiteDataMap site_data;
     86 };
     87 
     88 // MemoryGrowthTracker tracks latest metrics about record time and memory usage
     89 // at that time per process.
     90 class MemoryGrowthTracker {
     91  public:
     92   MemoryGrowthTracker();
     93   ~MemoryGrowthTracker();
     94 
     95   // If 30 minutes have passed since last UMA record, UpdateSample() computes
     96   // a difference between current memory usage |sample| of process |pid| and
     97   // stored memory usage at the time of last UMA record. Then, it updates the
     98   // stored memory usage to |sample|, stores the difference in |diff| and
     99   // returns true.
    100   // If no memory usage of |pid| has not been recorded so far or 30 minutes
    101   // have not passed since last record, it just returns false.
    102   // |sample| is memory usage in kB.
    103   bool UpdateSample(base::ProcessId pid, int sample, int* diff);
    104 
    105  private:
    106   // Latest metrics about record time and memory usage at that time per process.
    107   // The second values of |memory_sizes_| are in kB.
    108   std::map<base::ProcessId, base::TimeTicks> times_;
    109   std::map<base::ProcessId, int> memory_sizes_;
    110 
    111   DISALLOW_COPY_AND_ASSIGN(MemoryGrowthTracker);
    112 };
    113 
    114 #if defined(OS_MACOSX)
    115 class ProcessInfoSnapshot;
    116 #endif
    117 
    118 // MemoryDetails fetches memory details about current running browsers.
    119 // Because this data can only be fetched asynchronously, callers use
    120 // this class via a callback.
    121 //
    122 // Example usage:
    123 //
    124 //    class MyMemoryDetailConsumer : public MemoryDetails {
    125 //
    126 //      MyMemoryDetailConsumer() {
    127 //        // Anything but |StartFetch()|.
    128 //      }
    129 //
    130 //      // (Or just call |StartFetch()| explicitly if there's nothing else to
    131 //      // do.)
    132 //      void StartDoingStuff() {
    133 //        StartFetch();  // Starts fetching details.
    134 //        // Etc.
    135 //      }
    136 //
    137 //      // Your other class stuff here
    138 //
    139 //      virtual void OnDetailsAvailable() {
    140 //        // do work with memory info here
    141 //      }
    142 //    }
    143 class MemoryDetails : public base::RefCountedThreadSafe<MemoryDetails> {
    144  public:
    145   enum UserMetricsMode {
    146     UPDATE_USER_METRICS,  // Update UMA memory histograms with results.
    147     SKIP_USER_METRICS
    148   };
    149 
    150   // Constructor.
    151   MemoryDetails();
    152 
    153   // Access to the process detail information.  This data is only available
    154   // after OnDetailsAvailable() has been called.
    155   const std::vector<ProcessData>& processes() { return process_data_; }
    156 
    157   // Initiate updating the current memory details.  These are fetched
    158   // asynchronously because data must be collected from multiple threads.
    159   // Updates UMA memory histograms if |mode| is UPDATE_USER_METRICS.
    160   // OnDetailsAvailable will be called when this process is complete.
    161   void StartFetch(UserMetricsMode user_metrics_mode);
    162 
    163   virtual void OnDetailsAvailable() = 0;
    164 
    165   // Returns a string summarizing memory usage of the Chrome browser process
    166   // and all sub-processes, suitable for logging.
    167   std::string ToLogString();
    168 
    169  protected:
    170   friend class base::RefCountedThreadSafe<MemoryDetails>;
    171 
    172   virtual ~MemoryDetails();
    173 
    174   // Set MemoryGrowthTracker into MemoryDetails.
    175   void SetMemoryGrowthTracker(MemoryGrowthTracker* memory_growth_tracker);
    176 
    177  private:
    178   // Collect child process information on the IO thread.  This is needed because
    179   // information about some child process types (i.e. plugins) can only be taken
    180   // on that thread.  The data will be used by about:memory.  When finished,
    181   // invokes back to the file thread to run the rest of the about:memory
    182   // functionality.
    183   void CollectChildInfoOnIOThread();
    184 
    185   // Collect current process information from the OS and store it
    186   // for processing.  If data has already been collected, clears old
    187   // data and re-collects the data.
    188   // Note - this function enumerates memory details from many processes
    189   // and is fairly expensive to run, hence it's run on the file thread.
    190   // The parameter holds information about processes from the IO thread.
    191   void CollectProcessData(const std::vector<ProcessMemoryInformation>&);
    192 
    193 #if defined(OS_MACOSX)
    194   // A helper for |CollectProcessData()|, collecting data on the Chrome/Chromium
    195   // process with PID |pid|. The collected data is added to the state of the
    196   // object (in |process_data_|).
    197   void CollectProcessDataChrome(
    198       const std::vector<ProcessMemoryInformation>& child_info,
    199       base::ProcessId pid,
    200       const ProcessInfoSnapshot& process_info);
    201 #endif
    202 
    203   // Collect child process information on the UI thread.  Information about
    204   // renderer processes is only available there.
    205   void CollectChildInfoOnUIThread();
    206 
    207   // Updates the global histograms for tracking memory usage.
    208   void UpdateHistograms();
    209 
    210 #if defined(OS_CHROMEOS)
    211   void UpdateSwapHistograms();
    212 #endif
    213 
    214   // Returns a pointer to the ProcessData structure for Chrome.
    215   ProcessData* ChromeBrowser();
    216 
    217   std::vector<ProcessData> process_data_;
    218 
    219   UserMetricsMode user_metrics_mode_;
    220 
    221   // A pointer to MemoryGrowthTracker which is contained in a longer-lived
    222   // owner of MemoryDetails, for example, ChromeMetricsServiceClient.
    223   // The pointer is NULL by default and set by SetMemoryGrowthTracker().
    224   // If it is NULL, nothing is tracked.
    225   MemoryGrowthTracker* memory_growth_tracker_;
    226 
    227 #if defined(OS_CHROMEOS)
    228   base::SwapInfo swap_info_;
    229 #endif
    230 
    231   DISALLOW_COPY_AND_ASSIGN(MemoryDetails);
    232 };
    233 
    234 #endif  // CHROME_BROWSER_MEMORY_DETAILS_H_
    235