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 nsTArray<uint64_t>& id, nsPIDOMWindowInner* window);
  70
  71   /**
  72    * Get the list of window and process IDs we contain.
  73    */
  74   typedef nsTArray<uint64_t> IDArrayType;
  75   const IDArrayType& AsArray() const;
  76
  77   /**
  78    * Append the ID of the ContentChild singleton to our array of
  79    * window/process IDs.
  80    */
  81   void AppendProcessID();
  82
  83   /**
  84    * Does this WindowIdentifier identify both a window and the process
  85    * containing that window?  If so, we say it has traveled through
  86    * IPC.
  87    */
  88   bool HasTraveledThroughIPC() const;
  89
  90   /**
  91    * Get the window this object wraps.
  92    */
  93   nsPIDOMWindowInner* GetWindow() const;
  94
  95  private:
  96   /**
  97    * Get the ID of the window object we wrap.
  98    */
  99   uint64_t GetWindowID() const;
 100
 101   AutoTArray<uint64_t, 3> mID;
 102   nsCOMPtr<nsPIDOMWindowInner> mWindow;
 103   bool mIsEmpty;
 104 };
 105
 106 }  // namespace hal
 107 }  // namespace mozilla
 108
 109 #endif  // mozilla_hal_WindowIdentifier_h