[test] Move away from deprecated API for heap-related tests.

test/cctest/test-incremental-marking.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.
 
+// TODO(jochen): Remove this after the setting is turned on globally.
+#define V8_IMMINENT_DEPRECATION_WARNINGS
+
 #include <stdlib.h>
 
 #ifdef __linux__
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 #include <utility>
 
 #include "src/v8.h"
 
 #include "src/full-codegen/full-codegen.h"
 #include "src/global-handles.h"
 #include "test/cctest/cctest.h"
 
 using v8::IdleTask;
 using v8::Task;
 using v8::Isolate;
 
+namespace v8 {
+namespace internal {
 
 class MockPlatform : public v8::Platform {
  public:
   explicit MockPlatform(v8::Platform* platform)
       : platform_(platform), idle_task_(nullptr), delayed_task_(nullptr) {}
   virtual ~MockPlatform() {
     delete idle_task_;
     delete delayed_task_;
   }
 
   void CallOnBackgroundThread(Task* task,
                               ExpectedRuntime expected_runtime) override {
     platform_->CallOnBackgroundThread(task, expected_runtime);
   }
 
-  void CallOnForegroundThread(Isolate* isolate, Task* task) override {
+  void CallOnForegroundThread(v8::Isolate* isolate, Task* task) override {
     platform_->CallOnForegroundThread(isolate, task);
   }
 
-  void CallDelayedOnForegroundThread(Isolate* isolate, Task* task,
+  void CallDelayedOnForegroundThread(v8::Isolate* isolate, Task* task,
                                      double delay_in_seconds) override {
     if (delayed_task_ != nullptr) {
       delete delayed_task_;
     }
     delayed_task_ = task;
   }
 
   double MonotonicallyIncreasingTime() override {
     return platform_->MonotonicallyIncreasingTime();
   }
 
-  void CallIdleOnForegroundThread(Isolate* isolate, IdleTask* task) override {
+  void CallIdleOnForegroundThread(v8::Isolate* isolate,
+                                  IdleTask* task) override {
     CHECK(nullptr == idle_task_);
     idle_task_ = task;
   }
 
-  bool IdleTasksEnabled(Isolate* isolate) override { return true; }
+  bool IdleTasksEnabled(v8::Isolate* isolate) override { return true; }
 
   bool PendingIdleTask() { return idle_task_ != nullptr; }
 
   void PerformIdleTask(double idle_time_in_seconds) {
     IdleTask* task = idle_task_;
     idle_task_ = nullptr;
     task->Run(MonotonicallyIncreasingTime() + idle_time_in_seconds);
     delete task;
   }
 
@@ skipping 85 matching lines @@
   }
   // Once we stop notifying idle task progress, the delayed tasks
   // should finish marking.
   while (!marking->IsStopped() && platform.PendingDelayedTask()) {
     platform.PerformDelayedTask();
   }
   // There could be pending delayed task from memory reducer after GC finishes.
   CHECK(marking->IsStopped());
   i::V8::SetPlatformForTesting(old_platform);
 }
+
+}  // namespace internal
+}  // namespace v8