Implement <appview>

chrome/browser/guest_view/guest_view_base.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 "chrome/browser/guest_view/guest_view_base.h"
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/guest_view/app_view/app_view_guest.h"
@@ skipping 32 matching lines @@
 scoped_ptr<base::DictionaryValue> GuestViewBase::Event::GetArguments() {
   return args_.Pass();
 }
 
 // This observer ensures that the GuestViewBase destroys itself when its
 // embedder goes away.
 class GuestViewBase::EmbedderWebContentsObserver : public WebContentsObserver {
  public:
   explicit EmbedderWebContentsObserver(GuestViewBase* guest)
       : WebContentsObserver(guest->embedder_web_contents()),
+        destroyed_(false),
         guest_(guest) {
   }
 
   virtual ~EmbedderWebContentsObserver() {
   }
 
   // WebContentsObserver implementation.
   virtual void WebContentsDestroyed() OVERRIDE {
+    Destroy();
+  }
+
+  virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE {
+    Destroy();
+  }
+
+ private:
+  bool destroyed_;
+  GuestViewBase* guest_;
+
+  void Destroy() {
+    if (destroyed_)
+      return;
+    destroyed_ = true;
     guest_->embedder_web_contents_ = NULL;
     guest_->EmbedderDestroyed();
     guest_->Destroy();
   }
 
- private:
-  GuestViewBase* guest_;
-
   DISALLOW_COPY_AND_ASSIGN(EmbedderWebContentsObserver);
 };
 
 GuestViewBase::GuestViewBase(content::BrowserContext* browser_context,
                              int guest_instance_id)
     : embedder_web_contents_(NULL),
       embedder_render_process_id_(0),
       browser_context_(browser_context),
       guest_instance_id_(guest_instance_id),
       view_instance_id_(guestview::kInstanceIDNone),
       initialized_(false),
       weak_ptr_factory_(this) {
 }
 
 void GuestViewBase::Init(
     const std::string& embedder_extension_id,
     int embedder_render_process_id,
     const base::DictionaryValue& create_params,
     const WebContentsCreatedCallback& callback) {
   if (initialized_)
     return;
   initialized_ = true;
 
   CreateWebContents(embedder_extension_id,
                     embedder_render_process_id,
                     create_params,
-                    base::Bind(&GuestViewBase::CompleteCreateWebContents,
+                    base::Bind(&GuestViewBase::CompleteInit,
                                AsWeakPtr(),
                                embedder_extension_id,
                                embedder_render_process_id,
                                callback));
 }
 
 void GuestViewBase::InitWithWebContents(
     const std::string& embedder_extension_id,
     int embedder_render_process_id,
     content::WebContents* guest_web_contents) {
@@ skipping 101 matching lines @@
   CHECK(!attached());
   CHECK_EQ(host->GetID(), embedder_render_process_id());
 
   // This code path may be reached if the embedder WebContents is killed for
   // whatever reason immediately after a called to GuestViewInternal.createGuest
   // and before attaching the new guest to a frame.
   Destroy();
 }
 
 void GuestViewBase::Destroy() {
+  DCHECK(guest_web_contents());
   content::RenderProcessHost* host =
       content::RenderProcessHost::FromID(embedder_render_process_id());
   if (host)
     host->RemoveObserver(this);
   WillDestroy();
   if (!destruction_callback_.is_null())
     destruction_callback_.Run();
+
+  webcontents_guestview_map.Get().erase(guest_web_contents());
+  GuestViewManager::FromBrowserContext(browser_context_)->
+      RemoveGuest(guest_instance_id_);
+  pending_events_.clear();
+
   delete guest_web_contents();
 }
 
 void GuestViewBase::DidAttach() {
   // Give the derived class an opportunity to perform some actions.
   DidAttachToEmbedder();
 
   SendQueuedEvents();
 }
 
@@ skipping 51 matching lines @@
 }
 
 bool GuestViewBase::PreHandleGestureEvent(content::WebContents* source,
                                          const blink::WebGestureEvent& event) {
   return event.type == blink::WebGestureEvent::GesturePinchBegin ||
       event.type == blink::WebGestureEvent::GesturePinchUpdate ||
       event.type == blink::WebGestureEvent::GesturePinchEnd;
 }
 
 GuestViewBase::~GuestViewBase() {
-  std::pair<int, int> key(embedder_render_process_id_, guest_instance_id_);
-
-  webcontents_guestview_map.Get().erase(guest_web_contents());
-
-  GuestViewManager::FromBrowserContext(browser_context_)->
-      RemoveGuest(guest_instance_id_);
-
-  pending_events_.clear();
 }
 
 void GuestViewBase::DispatchEvent(Event* event) {
   scoped_ptr<Event> event_ptr(event);
   if (!in_extension()) {
     NOTREACHED();
     return;
   }
 
   if (!attached()) {
@@ skipping 21 matching lines @@
 void GuestViewBase::SendQueuedEvents() {
   if (!attached())
     return;
   while (!pending_events_.empty()) {
     linked_ptr<Event> event_ptr = pending_events_.front();
     pending_events_.pop_front();
     DispatchEvent(event_ptr.release());
   }
 }
 
-void GuestViewBase::CompleteCreateWebContents(
-    const std::string& embedder_extension_id,
-    int embedder_render_process_id,
-    const WebContentsCreatedCallback& callback,
-    content::WebContents* guest_web_contents) {
+void GuestViewBase::CompleteInit(const std::string& embedder_extension_id,
+                                 int embedder_render_process_id,
+                                 const WebContentsCreatedCallback& callback,
+                                 content::WebContents* guest_web_contents) {
   if (!guest_web_contents) {
+    // The derived class did not create a WebContents so this class serves no
+    // purpose. Let's self-destruct.
+    delete this;

[lazyboy, 2014/07/07 21:34:44]

Can you call callback.Run(this) after "delete this"?

[Fady Samuel, 2014/07/08 15:47:08]

Yes, this callback is a local variable. We can't access members.

     callback.Run(NULL);
     return;
   }
   InitWithWebContents(embedder_extension_id,
                       embedder_render_process_id,
                       guest_web_contents);
   callback.Run(guest_web_contents);
 }