Revert of Replace all remaining Oddball checks with new function

test/cctest/test-field-type-tracking.cc

 // 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.
 
 #include <stdlib.h>
 #include <utility>
 
 #include "test/cctest/test-api.h"
 
 #include "src/v8.h"
@@ skipping 370 matching lines @@
   Handle<Map> AddAccessorConstant(Handle<Map> map,
                                   PropertyAttributes attributes,
                                   Handle<Object> getter,
                                   Handle<Object> setter) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetAccessorConstant(property_index, attributes, getter, setter);
 
     Handle<String> name = MakeName("prop", property_index);
 
-    CHECK(!getter->IsNull(isolate_) || !setter->IsNull(isolate_));
+    CHECK(!getter->IsNull() || !setter->IsNull());
     Factory* factory = isolate_->factory();
 
-    if (!getter->IsNull(isolate_)) {
+    if (!getter->IsNull()) {
       Handle<AccessorPair> pair = factory->NewAccessorPair();
       pair->SetComponents(*getter, *factory->null_value());
       AccessorConstantDescriptor new_desc(name, pair, attributes);
       map = Map::CopyInsertDescriptor(map, &new_desc, INSERT_TRANSITION);
     }
-    if (!setter->IsNull(isolate_)) {
+    if (!setter->IsNull()) {
       Handle<AccessorPair> pair = factory->NewAccessorPair();
       pair->SetComponents(*getter, *setter);
       AccessorConstantDescriptor new_desc(name, pair, attributes);
       map = Map::CopyInsertDescriptor(map, &new_desc, INSERT_TRANSITION);
     }
     return map;
   }
 
   Handle<Map> TransitionToAccessorConstant(Handle<Map> map,
                                            PropertyAttributes attributes,
@@ skipping 68 matching lines @@
   expectations.SetDataField(0, NONE, Representation::Smi(), any_type);
   CHECK(prepared_map->is_stable());
   CHECK(expectations.Check(*prepared_map));
 
   // Now create an object with |map|, migrate it to |prepared_map| and ensure
   // that the data property is uninitialized.
   Factory* factory = isolate->factory();
   Handle<JSObject> obj = factory->NewJSObjectFromMap(map);
   JSObject::MigrateToMap(obj, prepared_map);
   FieldIndex index = FieldIndex::ForDescriptor(*prepared_map, 0);
-  CHECK(obj->RawFastPropertyAt(index)->IsUninitialized(isolate));
+  CHECK(obj->RawFastPropertyAt(index)->IsUninitialized());
 #ifdef VERIFY_HEAP
   obj->ObjectVerify();
 #endif
 }
 
 
 // This test checks that the LookupIterator machinery involved in
 // JSObject::SetOwnPropertyIgnoreAttributes() does not try to migrate object
 // to a map with a property with None representation.
 TEST(ReconfigureAccessorToNonExistingDataFieldHeavy) {
@@ skipping 137 matching lines @@
     CHECK_EQ(*map, *new_map);
 
     CHECK_EQ(expected_field_type_dependency, info.dependencies()->HasAborted());
   }
 
   {
     // Check that all previous maps are not stable.
     Map* tmp = *new_map;
     while (true) {
       Object* back = tmp->GetBackPointer();
-      if (back->IsUndefined(isolate)) break;
+      if (back->IsUndefined()) break;
       tmp = Map::cast(back);
       CHECK(!tmp->is_stable());
     }
   }
 
   info.dependencies()->Rollback();  // Properly cleanup compilation info.
 
   // Update all deprecated maps and check that they are now the same.
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
@@ skipping 577 matching lines @@
 };
 
 
 // Checks that given |map| is NOT deprecated, and |new_map| is a result of
 // copy-generalize-all-representations.
 struct CheckCopyGeneralizeAllRepresentations {
   void Check(Handle<Map> map, Handle<Map> new_map, Expectations& expectations) {
     CHECK(!map->is_deprecated());
     CHECK_NE(*map, *new_map);
 
-    CHECK(new_map->GetBackPointer()->IsUndefined(map->GetIsolate()));
+    CHECK(new_map->GetBackPointer()->IsUndefined());
     for (int i = 0; i < kPropCount; i++) {
       expectations.GeneralizeRepresentation(i);
     }
 
     CHECK(!new_map->is_deprecated());
     CHECK(expectations.Check(*new_map));
   }
 };
 
 
@@ skipping 610 matching lines @@
     Handle<String> name = MakeName("foo", i);
     Map::CopyWithField(map2, name, any_type, NONE, Representation::Smi(),
                        INSERT_TRANSITION)
         .ToHandleChecked();
   }
   CHECK(!TransitionArray::CanHaveMoreTransitions(map2));
 
   // Try to update |map|, since there is no place for propX transition at |map2|
   // |map| should become "copy-generalized".
   Handle<Map> updated_map = Map::Update(map);
-  CHECK(updated_map->GetBackPointer()->IsUndefined(isolate));
+  CHECK(updated_map->GetBackPointer()->IsUndefined());
 
   for (int i = 0; i < kPropCount; i++) {
     expectations.SetDataField(i, Representation::Tagged(), any_type);
   }
   CHECK(expectations.Check(*updated_map));
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests involving special transitions (such as elements kind
@@ skipping 79 matching lines @@
       // of Map::Update().
       CHECK_EQ(*new_map2, *tmp_map);
     }
 
     if (config.is_non_equevalent_transition()) {
       // In case of non-equivalent transition currently we generalize all
       // representations.
       for (int i = 0; i < kPropCount; i++) {
         expectations2.GeneralizeRepresentation(i);
       }
-      CHECK(new_map2->GetBackPointer()->IsUndefined(isolate));
+      CHECK(new_map2->GetBackPointer()->IsUndefined());
       CHECK(expectations2.Check(*new_map2));
     } else {
-      CHECK(!new_map2->GetBackPointer()->IsUndefined(isolate));
+      CHECK(!new_map2->GetBackPointer()->IsUndefined());
       CHECK(expectations2.Check(*new_map2));
     }
   }
 
   Handle<Map> active_map = maps[kPropCount - 1];
   CHECK(!active_map->is_deprecated());
 
   // Update all deprecated maps and check that they are now the same.
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*active_map, *updated_map);
@@ skipping 415 matching lines @@
   Handle<AccessorPair> pair = CreateAccessorPair(true, true);
   TransitionToAccessorConstantOperator transition_op(pair);
 
   SameMapChecker checker;
   TestTransitionTo(transition_op, transition_op, checker);
 }
 
 
 // TODO(ishell): add this test once IS_ACCESSOR_FIELD_SUPPORTED is supported.
 // TEST(TransitionAccessorConstantToAnotherAccessorConstant)