Revert of Remove more dead code after Object.observe removal

src/objects.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_OBJECTS_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 
 #include "src/assert-scope.h"
@@ skipping 1111 matching lines @@
   // ES6 section 7.2.13 Strict Equality Comparison
   bool StrictEquals(Object* that);
 
   // Convert to a JSObject if needed.
   // native_context is used when creating wrapper object.
   MUST_USE_RESULT static inline MaybeHandle<JSReceiver> ToObject(
       Isolate* isolate, Handle<Object> object);
   MUST_USE_RESULT static MaybeHandle<JSReceiver> ToObject(
       Isolate* isolate, Handle<Object> object, Handle<Context> context);
 
-  // ES6 section 9.2.1.2, OrdinaryCallBindThis for sloppy callee.
-  MUST_USE_RESULT static MaybeHandle<JSReceiver> ConvertReceiver(
-      Isolate* isolate, Handle<Object> object);
-
   // ES6 section 7.1.14 ToPropertyKey
   MUST_USE_RESULT static inline MaybeHandle<Name> ToName(Isolate* isolate,
                                                          Handle<Object> input);
 
   // ES6 section 7.1.1 ToPrimitive
   MUST_USE_RESULT static inline MaybeHandle<Object> ToPrimitive(
       Handle<Object> input, ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
 
   // ES6 section 7.1.3 ToNumber
   MUST_USE_RESULT static MaybeHandle<Object> ToNumber(Handle<Object> input);
 
   // ES6 section 7.1.4 ToInteger
   MUST_USE_RESULT static MaybeHandle<Object> ToInteger(Isolate* isolate,
                                                        Handle<Object> input);
 
   // ES6 section 7.1.5 ToInt32
   MUST_USE_RESULT static MaybeHandle<Object> ToInt32(Isolate* isolate,
                                                      Handle<Object> input);
 
   // ES6 section 7.1.6 ToUint32
   MUST_USE_RESULT static MaybeHandle<Object> ToUint32(Isolate* isolate,
                                                       Handle<Object> input);
 
   // ES6 section 7.1.12 ToString
   MUST_USE_RESULT static MaybeHandle<String> ToString(Isolate* isolate,
                                                       Handle<Object> input);
 
-  // ES6 section 7.1.14 ToPropertyKey
-  MUST_USE_RESULT static MaybeHandle<Object> ToPropertyKey(
-      Isolate* isolate, Handle<Object> value);
-
   // ES6 section 7.1.15 ToLength
   MUST_USE_RESULT static MaybeHandle<Object> ToLength(Isolate* isolate,
                                                       Handle<Object> input);
 
   // ES6 section 7.3.9 GetMethod
   MUST_USE_RESULT static MaybeHandle<Object> GetMethod(
       Handle<JSReceiver> receiver, Handle<Name> name);
 
   // ES6 section 7.3.17 CreateListFromArrayLike
   MUST_USE_RESULT static MaybeHandle<FixedArray> CreateListFromArrayLike(
@@ skipping 1002 matching lines @@
   // Retrieve interceptors.
   inline InterceptorInfo* GetNamedInterceptor();
   inline InterceptorInfo* GetIndexedInterceptor();
 
   // Used from JSReceiver.
   MUST_USE_RESULT static Maybe<PropertyAttributes>
   GetPropertyAttributesWithInterceptor(LookupIterator* it);
   MUST_USE_RESULT static Maybe<PropertyAttributes>
       GetPropertyAttributesWithFailedAccessCheck(LookupIterator* it);
 
+  // Retrieves an AccessorPair property from the given object. Might return
+  // undefined if the property doesn't exist or is of a different kind.
+  MUST_USE_RESULT static MaybeHandle<Object> GetAccessor(
+      Handle<JSObject> object,
+      Handle<Name> name,
+      AccessorComponent component);
+
   // Defines an AccessorPair property on the given object.
   // TODO(mstarzinger): Rename to SetAccessor().
   static MaybeHandle<Object> DefineAccessor(Handle<JSObject> object,
                                             Handle<Name> name,
                                             Handle<Object> getter,
                                             Handle<Object> setter,
                                             PropertyAttributes attributes);
   static MaybeHandle<Object> DefineAccessor(LookupIterator* it,
                                             Handle<Object> getter,
                                             Handle<Object> setter,
@@ skipping 93 matching lines @@
   inline int GetInternalFieldCount();
   inline int GetInternalFieldOffset(int index);
   inline Object* GetInternalField(int index);
   inline void SetInternalField(int index, Object* value);
   inline void SetInternalField(int index, Smi* value);
   bool WasConstructedFromApiFunction();
 
   void CollectOwnPropertyNames(KeyAccumulator* keys,
                                PropertyFilter filter = ALL_PROPERTIES);
 
+  // Returns the number of properties on this object filtering out properties
+  // with the specified attributes (ignoring interceptors).
+  // TODO(jkummerow): Deprecated, only used by Object.observe.
+  int NumberOfOwnElements(PropertyFilter filter);
+  // Returns the number of elements on this object filtering out elements
+  // with the specified attributes (ignoring interceptors).
+  // TODO(jkummerow): Deprecated, only used by Object.observe.
+  int GetOwnElementKeys(FixedArray* storage, PropertyFilter filter);
+
   static void CollectOwnElementKeys(Handle<JSObject> object,
                                     KeyAccumulator* keys,
                                     PropertyFilter filter);
 
   static Handle<FixedArray> GetEnumPropertyKeys(Handle<JSObject> object);
 
   static Handle<FixedArray> GetFastEnumPropertyKeys(Isolate* isolate,
                                                     Handle<JSObject> object);
 
   // Returns a new map with all transitions dropped from the object's current
@@ skipping 1162 matching lines @@
       Key key) {
     return DerivedHashTable::Shrink(dictionary, key);
   }
 
   // Sorting support
   // TODO(dcarney): templatize or move to SeededNumberDictionary
   void CopyValuesTo(FixedArray* elements);
 
   // Returns the number of elements in the dictionary filtering out properties
   // with the specified attributes.
+  // TODO(jkummerow): Deprecated, only used by Object.observe.
   int NumberOfElementsFilterAttributes(PropertyFilter filter);
 
   // Returns the number of enumerable elements in the dictionary.
+  // TODO(jkummerow): Deprecated, only used by Object.observe.
   int NumberOfEnumElements() {
     return NumberOfElementsFilterAttributes(ENUMERABLE_STRINGS);
   }
 
   enum SortMode { UNSORTED, SORTED };
 
+  // Fill in details for properties into storage.
+  // Returns the number of properties added.
+  // TODO(jkummerow): Deprecated, only used by Object.observe.
+  int CopyKeysTo(FixedArray* storage, int index, PropertyFilter filter,
+                 SortMode sort_mode);
   // Collect the keys into the given KeyAccumulator, in ascending chronological
   // order of property creation.
   static void CollectKeysTo(Handle<Dictionary<Derived, Shape, Key> > dictionary,
                             KeyAccumulator* keys, PropertyFilter filter);
 
   // Copies enumerable keys to preallocated fixed array.
   void CopyEnumKeysTo(FixedArray* storage);
 
   // Accessors for next enumeration index.
   void SetNextEnumerationIndex(int index) {
@@ skipping 7272 matching lines @@
     }
     return value;
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #endif  // V8_OBJECTS_H_