Make <webview> use out-of-process iframe architecture.

components/guest_view/renderer/guest_view_container.cc

 // Copyright 2014 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 "components/guest_view/renderer/guest_view_container.h"
 
 #include "components/guest_view/common/guest_view_constants.h"
 #include "components/guest_view/common/guest_view_messages.h"
 #include "components/guest_view/renderer/guest_view_request.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/render_view.h"
+#include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 
 namespace {
 
 using GuestViewContainerMap = std::map<int, guest_view::GuestViewContainer*>;
 static base::LazyInstance<GuestViewContainerMap> g_guest_view_container_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace guest_view {
@@ skipping 17 matching lines @@
     GuestViewContainer* container,
     content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame),
       container_(container) {}
 
 void GuestViewContainer::RenderFrameLifetimeObserver::OnDestruct() {
   container_->RenderFrameDestroyed();
 }
 
 GuestViewContainer::GuestViewContainer(content::RenderFrame* render_frame)
-    : element_instance_id_(guest_view::kInstanceIDNone),
+    : ready_(false),
+      element_instance_id_(guest_view::kInstanceIDNone),
       render_frame_(render_frame),
-      ready_(false),
       in_destruction_(false),
+      destruction_isolate_(nullptr),
       weak_ptr_factory_(this) {
   render_frame_lifetime_observer_.reset(
       new RenderFrameLifetimeObserver(this, render_frame_));
 }
 
 GuestViewContainer::~GuestViewContainer() {
   // Note: Cleanups should be done in GuestViewContainer::Destroy(), not here.
 }
 
 // static.
@@ skipping 16 matching lines @@
 void GuestViewContainer::Destroy(bool embedder_frame_destroyed) {
   if (in_destruction_)
     return;
 
   in_destruction_ = true;
 
   // Give our derived class an opportunity to perform some cleanup prior to
   // destruction.
   OnDestroy(embedder_frame_destroyed);
 
+  RunDestructionCallback(embedder_frame_destroyed);
+
   // Invalidate weak references to us to avoid late arriving tasks from running
   // during destruction
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   if (element_instance_id() != guest_view::kInstanceIDNone)
     g_guest_view_container_map.Get().erase(element_instance_id());
 
   if (pending_response_.get())
     pending_response_->ExecuteCallbackIfAvailable(0 /* argc */, nullptr);
 
   while (pending_requests_.size() > 0) {
     linked_ptr<GuestViewRequest> pending_request = pending_requests_.front();
     pending_requests_.pop_front();
     // Call the JavaScript callbacks with no arguments which implies an error.
     pending_request->ExecuteCallbackIfAvailable(0 /* argc */, nullptr);
   }
 
   delete this;
 }
 
+void GuestViewContainer::RegisterDestructionCallback(
+    v8::Local<v8::Function> callback,
+    v8::Isolate* isolate) {
+  destruction_callback_.Reset(isolate, callback);
+  destruction_isolate_ = isolate;
+}
+
 void GuestViewContainer::RenderFrameDestroyed() {
   OnRenderFrameDestroyed();
   render_frame_ = nullptr;
   Destroy(true /* embedder_frame_destroyed */);
 }
 
 void GuestViewContainer::IssueRequest(linked_ptr<GuestViewRequest> request) {
   EnqueueRequest(request);
   PerformPendingRequest();
 }
@@ skipping 12 matching lines @@
   pending_response_ = pending_request;
 }
 
 void GuestViewContainer::HandlePendingResponseCallback(
     const IPC::Message& message) {
   CHECK(pending_response_.get());
   linked_ptr<GuestViewRequest> pending_response(pending_response_.release());
   pending_response->HandleResponse(message);
 }
 
+void GuestViewContainer::RunDestructionCallback(bool embedder_frame_destroyed) {
+  // Do not attempt to run |destruction_callback_| if the embedder frame was
+  // destroyed. Trying to invoke callback on RenderFrame destruction results in
+  // assertion failure when calling WebScopedMicrotaskSuppression.
+  if (embedder_frame_destroyed)
+    return;
+
+  // Call the destruction callback, if one is registered.
+  if (!destruction_callback_.IsEmpty()) {
+    v8::HandleScope handle_scope(destruction_isolate_);
+    v8::Local<v8::Function> callback = v8::Local<v8::Function>::New(
+        destruction_isolate_, destruction_callback_);
+    v8::Local<v8::Context> context = callback->CreationContext();
+    if (context.IsEmpty())
+      return;
+
+    v8::Context::Scope context_scope(context);
+    blink::WebScopedMicrotaskSuppression suppression;
+
+    callback->Call(context->Global(), 0 /* argc */, nullptr);
+  }
+}
+
 void GuestViewContainer::OnHandleCallback(const IPC::Message& message) {
   // Handle the callback for the current request with a pending response.
   HandlePendingResponseCallback(message);
   // Perform the subsequent request if one exists.
   PerformPendingRequest();
 }
 
 bool GuestViewContainer::OnMessage(const IPC::Message& message) {
   return false;
 }
@@ skipping 27 matching lines @@
 
 void GuestViewContainer::DidDestroyElement() {
   Destroy(false);
 }
 
 base::WeakPtr<content::BrowserPluginDelegate> GuestViewContainer::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace guest_view