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 83711 a1b13ab3909dde6af2d27ba055b26f34dffbafb5
parent 83710 007e6ebef90eb270d1b6ab03bdab4765346b0b85
child 83712 d1bce65ac70db6debecd69292424aeca54ab814f
push id628
push userclegnitto@mozilla.com
push dateWed, 21 Dec 2011 14:41:57 +0000
treeherdermozilla-aurora@24a61ad789e8 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjlebar, cjones
bugs710745
milestone11.0a1
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 {