Bug 710745 - Don't expose WindowIdentifier in Hal.h. r=jlebar sr=cjones
authorMounir Lamouri <mounir.lamouri@gmail.com>
Sat, 17 Dec 2011 22:04:26 +0100
changeset 84899 a1b13ab3909dde6af2d27ba055b26f34dffbafb5
parent 84898 007e6ebef90eb270d1b6ab03bdab4765346b0b85
child 84900 d1bce65ac70db6debecd69292424aeca54ab814f
push id114
push userffxbld
push dateFri, 09 Mar 2012 01:01:18 +0000
treeherdermozilla-release@c081ebf13261 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjlebar, cjones
bugs710745
milestone11.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 710745 - Don't expose WindowIdentifier in Hal.h. r=jlebar sr=cjones
hal/Hal.cpp
hal/Hal.h
hal/Makefile.in
hal/WindowIdentifier.cpp
hal/WindowIdentifier.h
hal/android/AndroidHal.cpp
hal/sandbox/SandboxHal.cpp
--- a/hal/Hal.cpp
+++ b/hal/Hal.cpp
@@ -33,32 +33,29 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "Hal.h"
-#include "mozilla/dom/ContentChild.h"
-#include "mozilla/dom/TabChild.h"
 #include "mozilla/Util.h"
 #include "nsThreadUtils.h"
 #include "nsXULAppAPI.h"
 #include "mozilla/Observer.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMWindow.h"
-#include "nsPIDOMWindow.h"
 #include "mozilla/Services.h"
 #include "nsIWebNavigation.h"
 #include "nsITabChild.h"
 #include "nsIDocShell.h"
 #include "mozilla/ClearOnShutdown.h"
+#include "WindowIdentifier.h"
 
-using namespace mozilla::dom;
 using namespace mozilla::services;
 
 #define PROXY_IF_SANDBOXED(_call)                 \
   do {                                            \
     if (InSandbox()) {                            \
       hal_sandbox::_call;                         \
     } else {                                      \
       hal_impl::_call;                            \
@@ -112,88 +109,20 @@ nsAutoPtr<WindowIdentifier::IDArrayType>
 void InitLastIDToVibrate()
 {
   gLastIDToVibrate = new WindowIdentifier::IDArrayType();
   ClearOnShutdown(&gLastIDToVibrate);
 }
 
 } // anonymous namespace
 
-WindowIdentifier::WindowIdentifier()
-  : mWindow(nsnull)
-  , mIsEmpty(true)
-{
-}
-
-WindowIdentifier::WindowIdentifier(nsIDOMWindow *window)
-  : mWindow(window)
-  , mIsEmpty(false)
-{
-  mID.AppendElement(GetWindowID());
-}
-
-WindowIdentifier::WindowIdentifier(nsCOMPtr<nsIDOMWindow> &window)
-  : mWindow(window)
-  , mIsEmpty(false)
-{
-  mID.AppendElement(GetWindowID());
-}
-
-WindowIdentifier::WindowIdentifier(const nsTArray<uint64> &id, nsIDOMWindow *window)
-  : mID(id)
-  , mWindow(window)
-  , mIsEmpty(false)
-{
-  mID.AppendElement(GetWindowID());
-}
-
-WindowIdentifier::WindowIdentifier(const WindowIdentifier &other)
-  : mID(other.mID)
-  , mWindow(other.mWindow)
-  , mIsEmpty(other.mIsEmpty)
+void
+Vibrate(const nsTArray<uint32>& pattern, nsIDOMWindow* window)
 {
-}
-
-const InfallibleTArray<uint64>&
-WindowIdentifier::AsArray() const
-{
-  MOZ_ASSERT(!mIsEmpty);
-  return mID;
-}
-
-bool
-WindowIdentifier::HasTraveledThroughIPC() const
-{
-  MOZ_ASSERT(!mIsEmpty);
-  return mID.Length() >= 2;
-}
-
-void
-WindowIdentifier::AppendProcessID()
-{
-  MOZ_ASSERT(!mIsEmpty);
-  mID.AppendElement(ContentChild::GetSingleton()->GetID());
-}
-
-uint64
-WindowIdentifier::GetWindowID() const
-{
-  MOZ_ASSERT(!mIsEmpty);
-  nsCOMPtr<nsPIDOMWindow> pidomWindow = do_QueryInterface(mWindow);
-  if (!pidomWindow) {
-    return uint64(-1);
-  }
-  return pidomWindow->WindowID();
-}
-
-nsIDOMWindow*
-WindowIdentifier::GetWindow() const
-{
-  MOZ_ASSERT(!mIsEmpty);
-  return mWindow;
+  Vibrate(pattern, WindowIdentifier(window));
 }
 
 void
 Vibrate(const nsTArray<uint32>& pattern, const WindowIdentifier &id)
 {
   AssertMainThread();
 
   // Only active windows may start vibrations.  If |id| hasn't gone
@@ -219,16 +148,22 @@ Vibrate(const nsTArray<uint32>& pattern,
 
     // hal_impl doesn't need |id|. Send it an empty id, which will
     // assert if it's used.
     hal_impl::Vibrate(pattern, WindowIdentifier());
   }
 }
 
 void
+CancelVibrate(nsIDOMWindow* window)
+{
+  CancelVibrate(WindowIdentifier(window));
+}
+
+void
 CancelVibrate(const WindowIdentifier &id)
 {
   AssertMainThread();
 
   // Although only active windows may start vibrations, a window may
   // cancel its own vibration even if it's no longer active.
   //
   // After a window is marked as inactive, it sends a CancelVibrate
--- a/hal/Hal.h
+++ b/hal/Hal.h
@@ -38,126 +38,39 @@
  * ***** END LICENSE BLOCK ***** */
 
 #ifndef mozilla_Hal_h
 #define mozilla_Hal_h 1
 
 #include "base/basictypes.h"
 #include "mozilla/Types.h"
 #include "nsTArray.h"
-#include "nsCOMPtr.h"
-#include "nsIDOMWindow.h"
 #include "prlog.h"
 #include "mozilla/dom/battery/Types.h"
 
 #ifndef MOZ_HAL_NAMESPACE
 
+class nsIDOMWindow;
+
 namespace mozilla {
 namespace dom {
 class TabChild;
 class PBrowserChild;
 }
 }
 
 // Only include this hunk of code once, and include it before
 // HalImpl.h and HalSandbox.h.
 namespace mozilla {
 namespace hal {
 
 extern PRLogModuleInfo *sHalLog;
 #define HAL_LOG(msg) PR_LOG(sHalLog, PR_LOG_DEBUG, msg)
 
-/**
- * This class serves two purposes.
- *
- * First, this class wraps a pointer to a window.
- *
- * Second, WindowIdentifier lets us uniquely identify a window across
- * processes.  A window exposes an ID which is unique only within its
- * process.  Thus to identify a window, we need to know the ID of the
- * process which contains it.  But the scope of a process's ID is its
- * parent; that is, two processes with different parents might have
- * the same ID.
- *
- * So to identify a window, we need its ID plus the IDs of all the
- * processes in the path from the window's process to the root
- * process.  We throw in the IDs of the intermediate windows (a
- * content window is contained in a window at each level of the
- * process tree) for good measures.
- *
- * You can access this list of IDs by calling AsArray().
- */
-class WindowIdentifier
-{
-public:
-  /**
-   * Create an empty WindowIdentifier.  Calls to any of this object's
-   * public methods will assert -- an empty WindowIdentifier may be
-   * used only as a placeholder to code which promises not to touch
-   * the object.
-   */
-  WindowIdentifier();
-
-  /**
-   * Copy constructor.
-   */
-  WindowIdentifier(const WindowIdentifier& other);
-
-  /**
-   * Wrap the given window in a WindowIdentifier.  These two
-   * constructors automatically grab the window's ID and append it to
-   * the array of IDs.
-   *
-   * Note that these constructors allow an implicit conversion to a
-   * WindowIdentifier.
-   */
-  WindowIdentifier(nsIDOMWindow* window);
-  WindowIdentifier(nsCOMPtr<nsIDOMWindow> &window);
-
-  /**
-   * Create a new WindowIdentifier with the given id array and window.
-   * This automatically grabs the window's ID and appends it to the
-   * array.
-   */
-  WindowIdentifier(const nsTArray<uint64>& id, nsIDOMWindow* window);
-
-  /**
-   * Get the list of window and process IDs we contain.
-   */
-  typedef InfallibleTArray<uint64> IDArrayType;
-  const IDArrayType& AsArray() const;
-
-  /**
-   * Append the ID of the ContentChild singleton to our array of
-   * window/process IDs.
-   */
-  void AppendProcessID();
-
-  /**
-   * Does this WindowIdentifier identify both a window and the process
-   * containing that window?  If so, we say it has traveled through
-   * IPC.
-   */
-  bool HasTraveledThroughIPC() const;
-
-  /**
-   * Get the window this object wraps.
-   */
-  nsIDOMWindow* GetWindow() const;
-
-private:
-  /**
-   * Get the ID of the window object we wrap.
-   */
-  uint64 GetWindowID() const;
-
-  AutoInfallibleTArray<uint64, 3> mID;
-  nsCOMPtr<nsIDOMWindow> mWindow;
-  bool mIsEmpty;
-};
+class WindowIdentifier;
 
 } // namespace hal
 } // namespace mozilla
 
 // This goop plays some cpp tricks to ensure a uniform API across the
 // API entry point, "sandbox" implementations (for content processes),
 // and "impl" backends where the real work happens.  After this runs
 // through cpp, there will be three sets of identical APIs
@@ -189,36 +102,37 @@ namespace MOZ_HAL_NAMESPACE /*hal*/ {
  * |pattern| is an "on" element, the next is "off", and so on.
  *
  * If |pattern| is empty, any in-progress vibration is canceled.
  *
  * Only an active window within an active tab may call Vibrate; calls
  * from inactive windows and windows on inactive tabs do nothing.
  *
  * If you're calling hal::Vibrate from the outside world, pass an
- * nsIDOMWindow* or an nsCOMPtr<nsIDOMWindow>& in place of the
- * WindowIdentifier parameter.  It'll be converted to a WindowIdentifier
- * automatically.
+ * nsIDOMWindow* in place of the WindowIdentifier parameter.
+ * The method with WindowIdentifier will be called automatically.
  */
 void Vibrate(const nsTArray<uint32>& pattern,
+             nsIDOMWindow* aWindow);
+void Vibrate(const nsTArray<uint32>& pattern,
              const hal::WindowIdentifier &id);
 
 /**
  * Cancel a vibration started by the content window identified by
  * WindowIdentifier.
  *
  * If the window was the last window to start a vibration, the
  * cancellation request will go through even if the window is not
  * active.
  *
- * As with hal::Vibrate(), if you're calling hal::CancelVibrate from
- * the outside world, pass an nsIDOMWindow* or an
- * nsCOMPtr<nsIDOMWindow>&.  This will automatically be converted to a
- * WindowIdentifier object.
+ * As with hal::Vibrate(), if you're calling hal::CancelVibrate from the outside
+ * world, pass an nsIDOMWindow*. The method with WindowIdentifier will be called
+ * automatically.
  */
+void CancelVibrate(nsIDOMWindow* aWindow);
 void CancelVibrate(const hal::WindowIdentifier &id);
 
 /**
  * Inform the battery backend there is a new battery observer.
  * @param aBatteryObserver The observer that should be added.
  */
 void RegisterBatteryObserver(BatteryObserver* aBatteryObserver);
 
--- a/hal/Makefile.in
+++ b/hal/Makefile.in
@@ -60,16 +60,17 @@ EXPORTS_mozilla = \
   Hal.h \
   HalImpl.h \
   HalSandbox.h \
   $(NULL)
 
 CPPSRCS = \
   Hal.cpp \
   SandboxHal.cpp \
+  WindowIdentifier.cpp \
   $(NULL)
 
 ifeq (android,$(MOZ_WIDGET_TOOLKIT))
 CPPSRCS += AndroidHal.cpp
 else ifeq (Linux,$(OS_TARGET))
 CPPSRCS += LinuxHal.cpp
 ifdef MOZ_ENABLE_DBUS
 CPPSRCS += UPowerClient.cpp
new file mode 100644
--- /dev/null
+++ b/hal/WindowIdentifier.cpp
@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at:
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Code.
+ *
+ * The Initial Developer of the Original Code is
+ *   The Mozilla Foundation
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Justin Lebar <justin.lebar@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include "mozilla/dom/ContentChild.h"
+#include "WindowIdentifier.h"
+#include "nsPIDOMWindow.h"
+
+namespace mozilla {
+namespace hal {
+
+WindowIdentifier::WindowIdentifier()
+  : mWindow(nsnull)
+  , mIsEmpty(true)
+{
+}
+
+WindowIdentifier::WindowIdentifier(nsIDOMWindow *window)
+  : mWindow(window)
+  , mIsEmpty(false)
+{
+  mID.AppendElement(GetWindowID());
+}
+
+WindowIdentifier::WindowIdentifier(const nsTArray<uint64> &id, nsIDOMWindow *window)
+  : mID(id)
+  , mWindow(window)
+  , mIsEmpty(false)
+{
+  mID.AppendElement(GetWindowID());
+}
+
+WindowIdentifier::WindowIdentifier(const WindowIdentifier &other)
+  : mID(other.mID)
+  , mWindow(other.mWindow)
+  , mIsEmpty(other.mIsEmpty)
+{
+}
+
+const InfallibleTArray<uint64>&
+WindowIdentifier::AsArray() const
+{
+  MOZ_ASSERT(!mIsEmpty);
+  return mID;
+}
+
+bool
+WindowIdentifier::HasTraveledThroughIPC() const
+{
+  MOZ_ASSERT(!mIsEmpty);
+  return mID.Length() >= 2;
+}
+
+void
+WindowIdentifier::AppendProcessID()
+{
+  MOZ_ASSERT(!mIsEmpty);
+  mID.AppendElement(dom::ContentChild::GetSingleton()->GetID());
+}
+
+uint64
+WindowIdentifier::GetWindowID() const
+{
+  MOZ_ASSERT(!mIsEmpty);
+  nsCOMPtr<nsPIDOMWindow> pidomWindow = do_QueryInterface(mWindow);
+  if (!pidomWindow) {
+    return uint64(-1);
+  }
+  return pidomWindow->WindowID();
+}
+
+nsIDOMWindow*
+WindowIdentifier::GetWindow() const
+{
+  MOZ_ASSERT(!mIsEmpty);
+  return mWindow;
+}
+
+} // namespace hal
+} // namespace mozilla
new file mode 100644
--- /dev/null
+++ b/hal/WindowIdentifier.h
@@ -0,0 +1,142 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at:
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Code.
+ *
+ * The Initial Developer of the Original Code is
+ *   The Mozilla Foundation
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Justin Lebar <justin.lebar@gmail.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef mozilla_hal_WindowIdentifier_h
+#define mozilla_hal_WindowIdentifier_h
+
+#include "mozilla/Types.h"
+#include "nsTArray.h"
+#include "nsCOMPtr.h"
+#include "nsIDOMWindow.h"
+
+namespace mozilla {
+namespace hal {
+
+/**
+ * This class serves two purposes.
+ *
+ * First, this class wraps a pointer to a window.
+ *
+ * Second, WindowIdentifier lets us uniquely identify a window across
+ * processes.  A window exposes an ID which is unique only within its
+ * process.  Thus to identify a window, we need to know the ID of the
+ * process which contains it.  But the scope of a process's ID is its
+ * parent; that is, two processes with different parents might have
+ * the same ID.
+ *
+ * So to identify a window, we need its ID plus the IDs of all the
+ * processes in the path from the window's process to the root
+ * process.  We throw in the IDs of the intermediate windows (a
+ * content window is contained in a window at each level of the
+ * process tree) for good measures.
+ *
+ * You can access this list of IDs by calling AsArray().
+ */
+class WindowIdentifier
+{
+public:
+  /**
+   * Create an empty WindowIdentifier.  Calls to any of this object's
+   * public methods will assert -- an empty WindowIdentifier may be
+   * used only as a placeholder to code which promises not to touch
+   * the object.
+   */
+  WindowIdentifier();
+
+  /**
+   * Copy constructor.
+   */
+  WindowIdentifier(const WindowIdentifier& other);
+
+  /**
+   * Wrap the given window in a WindowIdentifier.  These two
+   * constructors automatically grab the window's ID and append it to
+   * the array of IDs.
+   *
+   * Note that these constructors allow an implicit conversion to a
+   * WindowIdentifier.
+   */
+  explicit WindowIdentifier(nsIDOMWindow* window);
+
+  /**
+   * Create a new WindowIdentifier with the given id array and window.
+   * This automatically grabs the window's ID and appends it to the
+   * array.
+   */
+  WindowIdentifier(const nsTArray<uint64>& id, nsIDOMWindow* window);
+
+  /**
+   * Get the list of window and process IDs we contain.
+   */
+  typedef InfallibleTArray<uint64> IDArrayType;
+  const IDArrayType& AsArray() const;
+
+  /**
+   * Append the ID of the ContentChild singleton to our array of
+   * window/process IDs.
+   */
+  void AppendProcessID();
+
+  /**
+   * Does this WindowIdentifier identify both a window and the process
+   * containing that window?  If so, we say it has traveled through
+   * IPC.
+   */
+  bool HasTraveledThroughIPC() const;
+
+  /**
+   * Get the window this object wraps.
+   */
+  nsIDOMWindow* GetWindow() const;
+
+private:
+  /**
+   * Get the ID of the window object we wrap.
+   */
+  uint64 GetWindowID() const;
+
+  AutoInfallibleTArray<uint64, 3> mID;
+  nsCOMPtr<nsIDOMWindow> mWindow;
+  bool mIsEmpty;
+};
+
+} // namespace hal
+} // namespace mozilla
+
+#endif // mozilla_hal_WindowIdentifier_h
--- a/hal/android/AndroidHal.cpp
+++ b/hal/android/AndroidHal.cpp
@@ -31,16 +31,17 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "Hal.h"
+#include "WindowIdentifier.h"
 #include "AndroidBridge.h"
 
 using mozilla::hal::WindowIdentifier;
 
 namespace mozilla {
 namespace hal_impl {
 
 void
--- a/hal/sandbox/SandboxHal.cpp
+++ b/hal/sandbox/SandboxHal.cpp
@@ -41,16 +41,17 @@
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/hal_sandbox/PHalChild.h"
 #include "mozilla/hal_sandbox/PHalParent.h"
 #include "mozilla/dom/TabParent.h"
 #include "mozilla/dom/TabChild.h"
 #include "mozilla/dom/battery/Types.h"
 #include "mozilla/Observer.h"
 #include "mozilla/unused.h"
+#include "WindowIdentifier.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::hal;
 
 namespace mozilla {
 namespace hal_sandbox {