Simplify ownership of a ThreadState's interruptors.

Source/modules/compositorworker/CompositorWorkerManager.cpp

 // Copyright 2015 The Chromium 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 "config.h"
 #include "modules/compositorworker/CompositorWorkerManager.h"
 
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8Initializer.h"
@@ skipping 71 matching lines @@
     if (m_workerCount > 1)
         return;
 
     m_thread->initialize();
 
     // Initialize the isolate at the same time.
     ASSERT(!m_isolate);
     m_isolate = V8PerIsolateData::initialize();
     V8Initializer::initializeWorker(m_isolate);
 
-    m_interruptor = adoptPtr(new V8IsolateInterruptor(m_isolate));
-    ThreadState::current()->addInterruptor(m_interruptor.get());
+    OwnPtr<V8IsolateInterruptor> interruptor = adoptPtr(new V8IsolateInterruptor(m_isolate));
+    ThreadState::current()->addInterruptor(interruptor.release());
     ThreadState::current()->registerTraceDOMWrappers(m_isolate, V8GCController::traceDOMWrappers);
 }
 
 void CompositorWorkerManager::shutdownBackingThread()
 {
     MutexLocker lock(m_mutex);
     ASSERT(m_thread->isCurrentThread());
     ASSERT(m_workerCount > 0);
     --m_workerCount;
     if (m_workerCount == 0) {
@@ skipping 10 matching lines @@
     ASSERT(m_isolate);
     // It is safe to use the existing isolate even if TerminateExecution() has been
     // called on it, without calling CancelTerminateExecution().
     return m_isolate;
 }
 
 void CompositorWorkerManager::willDestroyIsolate()
 {
     MutexLocker lock(m_mutex);
     ASSERT(m_thread->isCurrentThread());
-    if (m_workerCount == 1) {
+    if (m_workerCount == 1)
         V8PerIsolateData::willBeDestroyed(m_isolate);
-        ThreadState::current()->removeInterruptor(m_interruptor.get());
-    }
 }
 
 void CompositorWorkerManager::destroyIsolate()
 {
     MutexLocker lock(m_mutex);
     if (!m_thread) {
         ASSERT(m_workerCount == 0);
         V8PerIsolateData::destroy(m_isolate);
         m_isolate = nullptr;
     }
 }
 
 void CompositorWorkerManager::terminateV8Execution()
 {
     MutexLocker lock(m_mutex);
     ASSERT(isMainThread());
     if (m_workerCount > 1)
         return;
 
     v8::V8::TerminateExecution(m_isolate);
 }
 
 } // namespace blink