Handlify upper layers of LoadIC.

src/objects.h

Index: src/objects.h
diff --git a/src/objects.h b/src/objects.h
index fd5dc4a70455e0201598305361ffe957cf4e60b0..8bcd3aebd4d13d040f69b8a3b87ecc6328368d9a 100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -912,10 +912,19 @@ class Object : public MaybeObject {
       Object* receiver,
       String* key,
       PropertyAttributes* attributes);
+
+  static Handle<Object> GetProperty(Isolate* isolate,

[Kevin Millikin (Chromium), 2011/10/18 08:46:47]

I like the static functions for namespacing.  We should, at the same time,
remove the corresponding toplevel functions in handles.h.  In this case, we
should be able to get rid of

Handle<Object> GetProperty(Handle<JSReceiver>, Handle<String>, LookupResult*);

[ulan, 2011/10/18 09:31:00]

Done.

+                                    Handle<Object> object,
+                                    Handle<Object> receiver,
+                                    LookupResult* result,
+                                    Handle<String> key,
+                                    PropertyAttributes* attributes);
+
   MUST_USE_RESULT MaybeObject* GetProperty(Object* receiver,
                                            LookupResult* result,
                                            String* key,
                                            PropertyAttributes* attributes);
+
   MUST_USE_RESULT MaybeObject* GetPropertyWithDefinedGetter(Object* receiver,
                                                             JSReceiver* getter);
 
@@ -1835,6 +1844,11 @@ class JSObject: public JSReceiver {
   // dictionary.  Returns the backing after conversion.
   MUST_USE_RESULT MaybeObject* NormalizeElements();
 
+  static void UpdateMapCodeCache(Isolate* isolate,
+                                 Handle<JSObject> object,
+                                 Handle<String> name,
+                                 Handle<Code> code);
+
   MUST_USE_RESULT MaybeObject* UpdateMapCodeCache(String* name, Code* code);
 
   // Transform slow named properties to fast variants.