Bug 909514 - Include <new> before mozilla::Maybe (and move Maybe into mfbt/Maybe.h). r=waldo

--HG--
rename : mfbt/Util.h => mfbt/Maybe.h

content/events/src/nsEventListenerService.cpp

@@ -20,6 +20,7 @@
 #include "jsdIDebuggerService.h"
 #endif
 #include "nsDOMClassInfoID.h"
+#include "mozilla/Maybe.h"
 
 using namespace mozilla::dom;
 using mozilla::AutoSafeJSContext;

content/events/src/nsEventListenerService.h

@@ -13,6 +13,10 @@
 #include "jsapi.h"
 #include "mozilla/Attributes.h"
 
+namespace mozilla {
+template<typename T>
+class Maybe;
+} // namespace mozilla
 
 class nsEventListenerInfo : public nsIEventListenerInfo
 {

dom/bindings/BindingDeclarations.h

@@ -16,7 +16,8 @@
 #include "nsStringGlue.h"
 #include "js/Value.h"
 #include "js/RootingAPI.h"
-#include "mozilla/Util.h"
+#include "jsapi.h"
+#include "mozilla/Maybe.h"
 #include "nsCOMPtr.h"
 #include "nsDOMString.h"
 #include "nsStringBuffer.h"

dom/src/json/nsJSON.cpp

@@ -21,6 +21,7 @@
 #include "nsCRTGlue.h"
 #include "nsAutoPtr.h"
 #include "nsIScriptSecurityManager.h"
+#include "mozilla/Maybe.h"
 #include <algorithm>
 
 static const char kXPConnectServiceCID[] = "@mozilla.org/js/xpc/XPConnect;1";

gfx/layers/basic/BasicLayersImpl.h

@@ -14,7 +14,7 @@
 #include "gfxMatrix.h"                  // for gfxMatrix
 #include "ipc/AutoOpenSurface.h"        // for AutoOpenSurface
 #include "mozilla/Attributes.h"         // for MOZ_DELETE, MOZ_STACK_CLASS
-#include "mozilla/Util.h"               // for Maybe
+#include "mozilla/Maybe.h"              // for Maybe
 #include "mozilla/layers/LayersSurfaces.h"  // for SurfaceDescriptor
 #include "nsAutoPtr.h"                  // for nsRefPtr
 #include "nsDebug.h"                    // for NS_ASSERTION

image/src/ClippedImage.h

@@ -7,7 +7,7 @@
 #define MOZILLA_IMAGELIB_CLIPPEDIMAGE_H_
 
 #include "ImageWrapper.h"
-#include "mozilla/Util.h" // for Maybe
+#include "mozilla/Maybe.h"
 
 namespace mozilla {
 namespace image {

image/src/ImageMetadata.h

@@ -5,7 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <stdint.h>
-#include "mozilla/Util.h"
+#include "mozilla/Maybe.h"
 #include "nsSize.h"
 #include "Orientation.h"
 

js/src/jsproxy.h

@@ -7,6 +7,8 @@
 #ifndef jsproxy_h
 #define jsproxy_h
 
+#include "mozilla/Maybe.h"
+
 #include "jsapi.h"
 #include "jsfriendapi.h"
 

js/src/vm/Shape.h

@@ -9,6 +9,7 @@
 
 #include "mozilla/Attributes.h"
 #include "mozilla/GuardObjects.h"
+#include "mozilla/Maybe.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/TemplateLib.h"
 

js/xpconnect/src/nsCxPusher.h

@@ -5,7 +5,7 @@
 #define nsCxPusher_h
 
 #include "jsapi.h"
-#include "mozilla/Util.h"
+#include "mozilla/Maybe.h"
 #include "nsCOMPtr.h"
 
 namespace mozilla {

layout/base/nsRefreshDriver.h

@@ -20,7 +20,7 @@
 #include "nsClassHashtable.h"
 #include "nsHashKeys.h"
 #include "mozilla/Attributes.h"
-#include "mozilla/Util.h"
+#include "mozilla/Maybe.h"
 
 class nsPresContext;
 class nsIPresShell;

mfbt/Maybe.h

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* A class for lazily constructing an object without sticking it on the heap. */
+
+#ifndef mozilla_Maybe_h
+#define mozilla_Maybe_h
+
+#include "mozilla/Alignment.h"
+#include "mozilla/Assertions.h"
+
+// For placement new
+#include <new>
+
+namespace mozilla {
+
+/*
+ * Small utility for lazily constructing objects without using dynamic storage.
+ * When a Maybe<T> is constructed, it is |empty()|, i.e., no value of T has
+ * been constructed and no T destructor will be called when the Maybe<T> is
+ * destroyed. Upon calling |construct|, a T object will be constructed with the
+ * given arguments and that object will be destroyed when the owning Maybe<T>
+ * is destroyed.
+ *
+ * N.B. GCC seems to miss some optimizations with Maybe and may generate extra
+ * branches/loads/stores. Use with caution on hot paths.
+ */
+template<class T>
+class Maybe
+{
+    AlignedStorage2<T> storage;
+    bool constructed;
+
+    T& asT() { return *storage.addr(); }
+
+  public:
+    Maybe() { constructed = false; }
+    ~Maybe() { if (constructed) asT().~T(); }
+
+    bool empty() const { return !constructed; }
+
+    void construct() {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T();
+      constructed = true;
+    }
+
+    template<class T1>
+    void construct(const T1& t1) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1);
+      constructed = true;
+    }
+
+    template<class T1, class T2>
+    void construct(const T1& t1, const T2& t2) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3>
+    void construct(const T1& t1, const T2& t2, const T3& t3) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3, class T4>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3, t4);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3, class T4, class T5>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3, t4, t5);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3, class T4, class T5,
+             class T6>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
+                   const T6& t6) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3, class T4, class T5,
+             class T6, class T7>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
+                   const T6& t6, const T7& t7) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3, class T4, class T5,
+             class T6, class T7, class T8>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
+                   const T6& t6, const T7& t7, const T8& t8) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7, t8);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3, class T4, class T5,
+             class T6, class T7, class T8, class T9>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
+                   const T6& t6, const T7& t7, const T8& t8, const T9& t9) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7, t8, t9);
+      constructed = true;
+    }
+
+    template<class T1, class T2, class T3, class T4, class T5,
+             class T6, class T7, class T8, class T9, class T10>
+    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
+                   const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) {
+      MOZ_ASSERT(!constructed);
+      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+      constructed = true;
+    }
+
+    T* addr() {
+      MOZ_ASSERT(constructed);
+      return &asT();
+    }
+
+    T& ref() {
+      MOZ_ASSERT(constructed);
+      return asT();
+    }
+
+    const T& ref() const {
+      MOZ_ASSERT(constructed);
+      return const_cast<Maybe*>(this)->asT();
+    }
+
+    void destroy() {
+      ref().~T();
+      constructed = false;
+    }
+
+    void destroyIfConstructed() {
+      if (!empty())
+        destroy();
+    }
+
+  private:
+    Maybe(const Maybe& other) MOZ_DELETE;
+    const Maybe& operator=(const Maybe& other) MOZ_DELETE;
+};
+
+} // namespace mozilla
+
+#endif /* mozilla_Maybe_h */

mfbt/Util.h

@@ -22,147 +22,6 @@
 
 namespace mozilla {
 
-/*
- * Small utility for lazily constructing objects without using dynamic storage.
- * When a Maybe<T> is constructed, it is |empty()|, i.e., no value of T has
- * been constructed and no T destructor will be called when the Maybe<T> is
- * destroyed. Upon calling |construct|, a T object will be constructed with the
- * given arguments and that object will be destroyed when the owning Maybe<T>
- * is destroyed.
- *
- * N.B. GCC seems to miss some optimizations with Maybe and may generate extra
- * branches/loads/stores. Use with caution on hot paths.
- */
-template<class T>
-class Maybe
-{
-    AlignedStorage2<T> storage;
-    bool constructed;
-
-    T& asT() { return *storage.addr(); }
-
-  public:
-    Maybe() { constructed = false; }
-    ~Maybe() { if (constructed) asT().~T(); }
-
-    bool empty() const { return !constructed; }
-
-    void construct() {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T();
-      constructed = true;
-    }
-
-    template<class T1>
-    void construct(const T1& t1) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1);
-      constructed = true;
-    }
-
-    template<class T1, class T2>
-    void construct(const T1& t1, const T2& t2) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3>
-    void construct(const T1& t1, const T2& t2, const T3& t3) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3, class T4>
-    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3, t4);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3, class T4, class T5>
-    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3, t4, t5);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3, class T4, class T5,
-             class T6>
-    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
-                   const T6& t6) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3, class T4, class T5,
-             class T6, class T7>
-    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
-                   const T6& t6, const T7& t7) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3, class T4, class T5,
-             class T6, class T7, class T8>
-    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
-                   const T6& t6, const T7& t7, const T8& t8) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7, t8);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3, class T4, class T5,
-             class T6, class T7, class T8, class T9>
-    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
-                   const T6& t6, const T7& t7, const T8& t8, const T9& t9) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7, t8, t9);
-      constructed = true;
-    }
-
-    template<class T1, class T2, class T3, class T4, class T5,
-             class T6, class T7, class T8, class T9, class T10>
-    void construct(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5,
-                   const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) {
-      MOZ_ASSERT(!constructed);
-      ::new (storage.addr()) T(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
-      constructed = true;
-    }
-
-    T* addr() {
-      MOZ_ASSERT(constructed);
-      return &asT();
-    }
-
-    T& ref() {
-      MOZ_ASSERT(constructed);
-      return asT();
-    }
-
-    const T& ref() const {
-      MOZ_ASSERT(constructed);
-      return const_cast<Maybe*>(this)->asT();
-    }
-
-    void destroy() {
-      ref().~T();
-      constructed = false;
-    }
-
-    void destroyIfConstructed() {
-      if (!empty())
-        destroy();
-    }
-
-  private:
-    Maybe(const Maybe& other) MOZ_DELETE;
-    const Maybe& operator=(const Maybe& other) MOZ_DELETE;
-};
-
 /*
  * Safely subtract two pointers when it is known that end >= begin.  This avoids
  * the common compiler bug that if (size_t(end) - size_t(begin)) has the MSB

mfbt/exported_headers.mk

@@ -31,6 +31,7 @@ EXPORTS_mozilla += \
   Likely.h \
   LinkedList.h \
   MathAlgorithms.h \
+  Maybe.h \
   MemoryChecking.h \
   MemoryReporting.h \
   Move.h \

netwerk/base/src/nsMediaFragmentURIParser.h

@@ -6,7 +6,7 @@
 #if !defined(nsMediaFragmentURIParser_h__)
 #define nsMediaFragmentURIParser_h__
 
-#include "mozilla/Util.h" // Maybe
+#include "mozilla/Maybe.h"
 #include "nsIURI.h"
 #include "nsString.h"
 #include "nsRect.h"

startupcache/test/TestStartupCache.cpp

@@ -24,6 +24,7 @@
 #include "nsIXPConnect.h"
 #include "jsapi.h"
 #include "prio.h"
+#include "mozilla/Maybe.h"
 
 using namespace JS;