hal/WindowIdentifier.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set sw=2 ts=8 et ft=cpp : */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_hal_WindowIdentifier_h
   8 #define mozilla_hal_WindowIdentifier_h
   9
  10 #include "mozilla/Types.h"
  11 #include "nsCOMPtr.h"
  12 #include "nsTArray.h"
  13
  14 class nsPIDOMWindowInner;
  15
  16 namespace mozilla {
  17 namespace hal {
  18
  19 /**
  20  * This class serves two purposes.
  21  *
  22  * First, this class wraps a pointer to a window.
  23  *
  24  * Second, WindowIdentifier lets us uniquely identify a window across
  25  * processes.  A window exposes an ID which is unique only within its
  26  * process.  Thus to identify a window, we need to know the ID of the
  27  * process which contains it.  But the scope of a process's ID is its
  28  * parent; that is, two processes with different parents might have
  29  * the same ID.
  30  *
  31  * So to identify a window, we need its ID plus the IDs of all the
  32  * processes in the path from the window's process to the root
  33  * process.  We throw in the IDs of the intermediate windows (a
  34  * content window is contained in a window at each level of the
  35  * process tree) for good measures.
  36  *
  37  * You can access this list of IDs by calling AsArray().
  38  */
  39 class WindowIdentifier {
  40  public:
  41   /**
  42    * Create an empty WindowIdentifier.  Calls to any of this object's
  43    * public methods will assert -- an empty WindowIdentifier may be
  44    * used only as a placeholder to code which promises not to touch
  45    * the object.
  46    */
  47   WindowIdentifier();
  48
  49   /**
  50    * Copy constructor.
  51    */
  52   WindowIdentifier(const WindowIdentifier& other);
  53
  54   /**
  55    * Wrap the given window in a WindowIdentifier.  These two
  56    * constructors automatically grab the window's ID and append it to
  57    * the array of IDs.
  58    *
  59    * Note that these constructors allow an implicit conversion to a
  60    * WindowIdentifier.
  61    */
  62   explicit WindowIdentifier(nsPIDOMWindowInner* window);
  63
  64   /**
  65    * Create a new WindowIdentifier with the given id array and window.
  66    * This automatically grabs the window's ID and appends it to the
  67    * array.
  68    */
  69   WindowIdentifier(const InfallibleTArray<uint64_t>& id,
  70                    nsPIDOMWindowInner* window);
  71
  72   /**
  73    * Get the list of window and process IDs we contain.
  74    */
  75   typedef InfallibleTArray<uint64_t> IDArrayType;
  76   const IDArrayType& AsArray() const;
  77
  78   /**
  79    * Append the ID of the ContentChild singleton to our array of
  80    * window/process IDs.
  81    */
  82   void AppendProcessID();
  83
  84   /**
  85    * Does this WindowIdentifier identify both a window and the process
  86    * containing that window?  If so, we say it has traveled through
  87    * IPC.
  88    */
  89   bool HasTraveledThroughIPC() const;
  90
  91   /**
  92    * Get the window this object wraps.
  93    */
  94   nsPIDOMWindowInner* GetWindow() const;
  95
  96  private:
  97   /**
  98    * Get the ID of the window object we wrap.
  99    */
 100   uint64_t GetWindowID() const;
 101
 102   AutoTArray<uint64_t, 3> mID;
 103   nsCOMPtr<nsPIDOMWindowInner> mWindow;
 104   bool mIsEmpty;
 105 };
 106
 107 }  // namespace hal
 108 }  // namespace mozilla
 109
 110 #endif  // mozilla_hal_WindowIdentifier_h