Bug 1447442 - Part 13: Remove additional unused declarations. r=jorendorff
authorAndré Bargull <andre.bargull@gmail.com>
Fri, 13 Apr 2018 02:26:02 -0700
changeset 413341 70d1fd2ca5c6cc4f830dcd3f049c53f24b3597aa
parent 413340 2b300e277494b2aa2ed79d36118f4aa4b84e328e
child 413342 bedd95bcb7987f1f3484ad5e8d0d6b09b9a316b1
push id33843
push usernerli@mozilla.com
push dateSat, 14 Apr 2018 09:49:25 +0000
treeherdermozilla-central@37b8862d354e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjorendorff
bugs1447442
milestone61.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 1447442 - Part 13: Remove additional unused declarations. r=jorendorff
js/src/builtin/DataViewObject.h
js/src/builtin/ModuleObject.h
js/src/builtin/Object.h
js/src/builtin/Stream.h
js/src/jsapi.h
js/src/jsfriendapi.h
js/src/jspubtd.h
--- a/js/src/builtin/DataViewObject.h
+++ b/js/src/builtin/DataViewObject.h
@@ -152,17 +152,16 @@ class DataViewObject : public NativeObje
     static bool fun_setUint32(JSContext* cx, unsigned argc, Value* vp);
 
     static bool setFloat32Impl(JSContext* cx, const CallArgs& args);
     static bool fun_setFloat32(JSContext* cx, unsigned argc, Value* vp);
 
     static bool setFloat64Impl(JSContext* cx, const CallArgs& args);
     static bool fun_setFloat64(JSContext* cx, unsigned argc, Value* vp);
 
-    static bool initClass(JSContext* cx);
     template<typename NativeType>
     static bool read(JSContext* cx, Handle<DataViewObject*> obj, const CallArgs& args,
                      NativeType* val);
     template<typename NativeType>
     static bool write(JSContext* cx, Handle<DataViewObject*> obj, const CallArgs& args);
 
     void notifyBufferDetached(void* newData);
 
--- a/js/src/builtin/ModuleObject.h
+++ b/js/src/builtin/ModuleObject.h
@@ -43,17 +43,16 @@ class ImportEntryObject : public NativeO
         ImportNameSlot,
         LocalNameSlot,
         LineNumberSlot,
         ColumnNumberSlot,
         SlotCount
     };
 
     static const Class class_;
-    static JSObject* initClass(JSContext* cx, HandleObject obj);
     static bool isInstance(HandleValue value);
     static ImportEntryObject* create(JSContext* cx,
                                      HandleAtom moduleRequest,
                                      HandleAtom importName,
                                      HandleAtom localName,
                                      uint32_t lineNumber,
                                      uint32_t columnNumber);
     JSAtom* moduleRequest() const;
@@ -76,17 +75,16 @@ class ExportEntryObject : public NativeO
         ImportNameSlot,
         LocalNameSlot,
         LineNumberSlot,
         ColumnNumberSlot,
         SlotCount
     };
 
     static const Class class_;
-    static JSObject* initClass(JSContext* cx, HandleObject obj);
     static bool isInstance(HandleValue value);
     static ExportEntryObject* create(JSContext* cx,
                                      HandleAtom maybeExportName,
                                      HandleAtom maybeModuleRequest,
                                      HandleAtom maybeImportName,
                                      HandleAtom maybeLocalName,
                                      uint32_t lineNumber,
                                      uint32_t columnNumber);
@@ -108,17 +106,16 @@ class RequestedModuleObject : public Nat
     {
         ModuleSpecifierSlot = 0,
         LineNumberSlot,
         ColumnNumberSlot,
         SlotCount
     };
 
     static const Class class_;
-    static JSObject* initClass(JSContext* cx, HandleObject obj);
     static bool isInstance(HandleValue value);
     static RequestedModuleObject* create(JSContext* cx,
                                          HandleAtom moduleSpecifier,
                                          uint32_t lineNumber,
                                          uint32_t columnNumber);
     JSAtom* moduleSpecifier() const;
     uint32_t lineNumber() const;
     uint32_t columnNumber() const;
--- a/js/src/builtin/Object.h
+++ b/js/src/builtin/Object.h
@@ -7,17 +7,16 @@
 #ifndef builtin_Object_h
 #define builtin_Object_h
 
 #include "jsapi.h"
 
 #include "vm/NativeObject.h"
 
 namespace JS {
-class CallArgs;
 union Value;
 } // namespace JS
 
 namespace js {
 
 // Object constructor native. Exposed only so the JIT can know its address.
 MOZ_MUST_USE bool
 obj_construct(JSContext* cx, unsigned argc, JS::Value* vp);
@@ -59,15 +58,11 @@ GetOwnPropertyDescriptorToArray(JSContex
  */
 MOZ_MUST_USE bool
 IdToStringOrSymbol(JSContext* cx, JS::HandleId id, JS::MutableHandleValue result);
 
 // Object.prototype.toSource. Function.prototype.toSource and uneval use this.
 JSString*
 ObjectToSource(JSContext* cx, JS::HandleObject obj);
 
-extern MOZ_MUST_USE bool
-WatchHandler(JSContext* cx, JSObject* obj, jsid id, const JS::Value& old,
-             JS::Value* nvp, void* closure);
-
 } /* namespace js */
 
 #endif /* builtin_Object_h */
--- a/js/src/builtin/Stream.h
+++ b/js/src/builtin/Stream.h
@@ -8,18 +8,16 @@
 #define builtin_Stream_h
 
 #include "builtin/Promise.h"
 #include "vm/NativeObject.h"
 
 
 namespace js {
 
-class AutoSetNewObjectMetadata;
-
 class ReadableStream : public NativeObject
 {
   public:
     static ReadableStream* createDefaultStream(JSContext* cx, HandleValue underlyingSource,
                                                HandleValue size, HandleValue highWaterMark,
                                                HandleObject proto = nullptr);
     static ReadableStream* createByteStream(JSContext* cx, HandleValue underlyingSource,
                                             HandleValue highWaterMark,
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -442,19 +442,16 @@ enum class PromiseRejectionHandlingState
 
 } /* namespace JS */
 
 typedef void
 (* JSPromiseRejectionTrackerCallback)(JSContext* cx, JS::HandleObject promise,
                                       JS::PromiseRejectionHandlingState state,
                                       void* data);
 
-typedef void
-(* JSProcessPromiseCallback)(JSContext* cx, JS::HandleObject promise);
-
 /**
  * Possible exception types. These types are part of a JSErrorFormatString
  * structure. They define which error to throw in case of a runtime error.
  *
  * JSEXN_WARN is used for warnings in js.msg files (for instance because we
  * don't want to prepend 'Error:' to warning messages). This value can go away
  * if we ever decide to use an entirely separate mechanism for warnings.
  */
--- a/js/src/jsfriendapi.h
+++ b/js/src/jsfriendapi.h
@@ -71,19 +71,16 @@ JS_NewObjectWithUniqueType(JSContext* cx
  * Allocate an object in exactly the same way as JS_NewObjectWithGivenProto, but
  * without invoking the metadata callback on it.  This allows creation of
  * internal bookkeeping objects that are guaranteed to not have metadata
  * attached to them.
  */
 extern JS_FRIEND_API(JSObject*)
 JS_NewObjectWithoutMetadata(JSContext* cx, const JSClass* clasp, JS::Handle<JSObject*> proto);
 
-extern JS_FRIEND_API(uint32_t)
-JS_ObjectCountDynamicSlots(JS::HandleObject obj);
-
 extern JS_FRIEND_API(bool)
 JS_NondeterministicGetWeakMapKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
 
 extern JS_FRIEND_API(bool)
 JS_NondeterministicGetWeakSetKeys(JSContext* cx, JS::HandleObject obj, JS::MutableHandleObject ret);
 
 // Raw JSScript* because this needs to be callable from a signal handler.
 extern JS_FRIEND_API(unsigned)
@@ -223,19 +220,16 @@ JS_CloneObject(JSContext* cx, JS::Handle
  * dst needs to have the compartment global as its parent.  This function will
  * preserve the existing metadata on dst, if any.
  */
 extern JS_FRIEND_API(bool)
 JS_InitializePropertiesFromCompatibleNativeObject(JSContext* cx,
                                                   JS::HandleObject dst,
                                                   JS::HandleObject src);
 
-extern JS_FRIEND_API(JSString*)
-JS_BasicObjectToString(JSContext* cx, JS::HandleObject obj);
-
 namespace js {
 
 JS_FRIEND_API(bool)
 GetBuiltinClass(JSContext* cx, JS::HandleObject obj, ESClass* cls);
 
 JS_FRIEND_API(const char*)
 ObjectClassName(JSContext* cx, JS::HandleObject obj);
 
--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -76,18 +76,16 @@ struct JSPropertySpec;
 struct JSSecurityCallbacks;
 struct JSStructuredCloneCallbacks;
 struct JSStructuredCloneReader;
 struct JSStructuredCloneWriter;
 class JS_PUBLIC_API(JSTracer);
 
 class JSFlatString;
 
-typedef bool                    (*JSInitCallback)(void);
-
 template<typename T> struct JSConstScalarSpec;
 typedef JSConstScalarSpec<double> JSConstDoubleSpec;
 typedef JSConstScalarSpec<int32_t> JSConstIntegerSpec;
 
 namespace js {
 namespace gc {
 class AutoTraceSession;
 class StoreBuffer;
@@ -106,17 +104,16 @@ JS_FRIEND_API(bool)
 CurrentThreadIsPerformingGC();
 #endif
 
 } // namespace js
 
 namespace JS {
 
 class JS_PUBLIC_API(AutoEnterCycleCollection);
-class JS_PUBLIC_API(AutoAssertOnBarrier);
 struct JS_PUBLIC_API(PropertyDescriptor);
 
 typedef void (*OffThreadCompileCallback)(void* token, void* callbackData);
 
 enum class HeapState {
     Idle,             // doing nothing with the GC heap
     Tracing,          // tracing the GC heap without collecting, e.g. IterateCompartments()
     MajorCollecting,  // doing a GC of the major heap