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 {
  41 public:
  42   /**
  43    * Create an empty WindowIdentifier.  Calls to any of this object's
  44    * public methods will assert -- an empty WindowIdentifier may be
  45    * used only as a placeholder to code which promises not to touch
  46    * the object.
  47    */
  48   WindowIdentifier();
  49
  50   /**
  51    * Copy constructor.
  52    */
  53   WindowIdentifier(const WindowIdentifier& other);
  54
  55   /**
  56    * Wrap the given window in a WindowIdentifier.  These two
  57    * constructors automatically grab the window's ID and append it to
  58    * the array of IDs.
  59    *
  60    * Note that these constructors allow an implicit conversion to a
  61    * WindowIdentifier.
  62    */
  63   explicit WindowIdentifier(nsPIDOMWindowInner* window);
  64
  65   /**
  66    * Create a new WindowIdentifier with the given id array and window.
  67    * This automatically grabs the window's ID and appends it to the
  68    * array.
  69    */
  70   WindowIdentifier(const InfallibleTArray<uint64_t>& id,
  71                    nsPIDOMWindowInner* window);
  72
  73   /**
  74    * Get the list of window and process IDs we contain.
  75    */
  76   typedef InfallibleTArray<uint64_t> IDArrayType;
  77   const IDArrayType& AsArray() const;
  78
  79   /**
  80    * Append the ID of the ContentChild singleton to our array of
  81    * window/process IDs.
  82    */
  83   void AppendProcessID();
  84
  85   /**
  86    * Does this WindowIdentifier identify both a window and the process
  87    * containing that window?  If so, we say it has traveled through
  88    * IPC.
  89    */
  90   bool HasTraveledThroughIPC() const;
  91
  92   /**
  93    * Get the window this object wraps.
  94    */
  95   nsPIDOMWindowInner* GetWindow() const;
  96
  97 private:
  98   /**
  99    * Get the ID of the window object we wrap.
 100    */
 101   uint64_t GetWindowID() const;
 102
 103   AutoTArray<uint64_t, 3> mID;
 104   nsCOMPtr<nsPIDOMWindowInner> mWindow;
 105   bool mIsEmpty;
 106 };
 107
 108 } // namespace hal
 109 } // namespace mozilla
 110
 111 #endif // mozilla_hal_WindowIdentifier_h