Remove GuestWebContentsCreated

chrome/browser/guest_view/guest_view_base.h

 // 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.
 
 #ifndef CHROME_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_
 #define CHROME_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_
 
 #include <queue>
 
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "content/public/browser/browser_plugin_guest_delegate.h"
+#include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 
 struct RendererContentSettingRules;
 
 // A GuestViewBase is the base class browser-side API implementation for a
 // <*view> tag. GuestViewBase maintains an association between a guest
 // WebContents and an embedder WebContents. It receives events issued from
 // the guest and relays them to the embedder.
 class GuestViewBase : public content::BrowserPluginGuestDelegate,
+                      public content::RenderProcessHostObserver,
                       public content::WebContentsDelegate,
                       public content::WebContentsObserver {
  public:
   class Event {
    public:
     Event(const std::string& name, scoped_ptr<base::DictionaryValue> args);
     ~Event();
 
     const std::string& name() const { return name_; }
 
     scoped_ptr<base::DictionaryValue> GetArguments();
 
    private:
     const std::string name_;
     scoped_ptr<base::DictionaryValue> args_;
   };
 
   // Returns a *ViewGuest if this GuestView is of the given view type.
   template <typename T>
   T* As() {
     if (IsViewType(T::Type))
       return static_cast<T*>(this);
 
     return NULL;
   }
 
   static GuestViewBase* Create(int guest_instance_id,
-                               content::WebContents* guest_web_contents,
-                               const std::string& embedder_extension_id,
                                const std::string& view_type);
 
   static GuestViewBase* FromWebContents(content::WebContents* web_contents);
 
   static GuestViewBase* From(int embedder_process_id, int instance_id);
 
   static bool IsGuest(content::WebContents* web_contents);
 
   // By default, JavaScript and images are enabled in guest content.
   static void GetDefaultContentSettingRules(RendererContentSettingRules* rules,
                                             bool incognito);
 
   virtual const char* GetViewType() const = 0;
 
   // This method is called after the guest has been attached to an embedder.
   //
   // This method can be overriden by subclasses. This gives the derived class
   // an opportunity to perform setup actions after attachment.
   virtual void DidAttach() {}
 
   // This method can be overridden by subclasses. This method is called when
   // the initial set of frames within the page have completed loading.
   virtual void DidStopLoading() {}
 
-  // This method is called when the guest WebContents is about to be destroyed.
-  //
-  // This method can be overridden by subclasses. This gives the derived class
-  // an opportunity to perform some cleanup prior to destruction.
-  virtual void WillDestroy() {}
-
   // This method is called when the guest's embedder WebContents has been
   // destroyed and the guest will be destroyed shortly.
   //
   // This method can be overridden by subclasses. This gives the derived class
   // an opportunity to perform some cleanup prior to destruction.
   virtual void EmbedderDestroyed() {}
 
   // This method is called when the guest WebContents has been destroyed. This
   // object will be destroyed after this call returns.
   //
   // This method can be overridden by subclasses. This gives the derived class
-  // opportunity to perform some cleanup.
+  // an opportunity to perform some cleanup.
   virtual void GuestDestroyed() {}
 
+  // This method is called after this GuestViewBase has been initiated.
+  //
+  // This method can be overriden by subclasses. This gives the derived class

[lazyboy, 2014/06/17 23:46:45]

"This method can be overriden by subclasses." -> I think the function being
virtual pretty much says that. So get rid of these.

[Fady Samuel, 2014/06/18 21:08:33]

Done.

+  // an opportunity to perform additional initialization.
+  virtual void Init() {}
+
   // This method queries whether drag-and-drop is enabled for this particular
   // view. By default, drag-and-drop is disabled. Derived classes can override
   // this behavior to enable drag-and-drop.
   virtual bool IsDragAndDropEnabled() const;
 
-  // Once a guest WebContents is ready, this initiates the association of |this|
-  // GuestView with |guest_web_contents|.
-  void Init(content::WebContents* guest_web_contents,
-            const std::string& embedder_extension_id);
+  // This method is called when the guest WebContents is about to be destroyed.
+  //
+  // This method can be overridden by subclasses. This gives the derived class
+  // an opportunity to perform some cleanup prior to destruction.
+  virtual void WillDestroy() {}
+
+  // This method is to be implemented by the derived class. Given a set of
+  // initialization parameters, a concrete subclass of GuestViewBase can
+  // create a specialized WebContents that it returns back to GuestViewBase.
+  typedef base::Callback<void(content::WebContents*)> WebContentsCallback;

[lazyboy, 2014/06/17 23:46:45]

WebContentsCreatedCallback

[Fady Samuel, 2014/06/18 21:08:33]

Done.

+  virtual void CreateWebContents(
+      const std::string& embedder_extension_id,
+      content::RenderProcessHost* embedder_render_process_host,
+      const base::DictionaryValue& create_params,
+      const WebContentsCallback& callback) = 0;
+
+  // This creates a WebContents and initializes |this| GuestViewBase to use the
+  // newly created WebContents.
+  void Init(const std::string& embedder_extension_id,

[lazyboy, 2014/06/17 23:46:45]

I found this function very confusing with the virtual Init().
One of them needs to be renamed.

[Fady Samuel, 2014/06/18 21:08:33]

This pattern is used elsewhere: See DidStopLoading. The idea is some work needs
to be done in the base class and other work needs to be done in the derived
class. It should not be possible for the derived class to circumvent the work
being done in the base class. I have nothing against another name but I can't
think of a good one :P I'm open to suggestions :-)

[lazyboy, 2014/06/19 16:17:31]

Since the parameterless Init() is called after initialization, how about
DidInitialize() for the other one?

[Fady Samuel, 2014/06/20 15:16:35]

Good idea! Done!

+            content::RenderProcessHost* embedder_render_process_host,
+            const base::DictionaryValue& create_params);
+
+  void InitWithWebContents(
+      const std::string& embedder_extension_id,
+      content::RenderProcessHost* embedder_render_process_host,
+      content::WebContents* guest_web_contents);
 
   bool IsViewType(const char* const view_type) const {
     return !strcmp(GetViewType(), view_type);
   }
 
   base::WeakPtr<GuestViewBase> AsWeakPtr();
 
+  bool initialized() const { return initialized_; }
+
   content::WebContents* embedder_web_contents() const {
     return embedder_web_contents_;
   }
 
   // Returns the guest WebContents.
   content::WebContents* guest_web_contents() const {
     return web_contents();
   }
 
   // Returns the extra parameters associated with this GuestView passed
@@ skipping 24 matching lines @@
 
   // Returns the embedder's process ID.
   int embedder_render_process_id() const { return embedder_render_process_id_; }
 
   GuestViewBase* GetOpener() const {
     return opener_.get();
   }
 
   void SetOpener(GuestViewBase* opener);
 
+  // RenderProcessHostObserver implementation
+  virtual void RenderProcessExited(content::RenderProcessHost* host,
+                                   base::ProcessHandle handle,
+                                   base::TerminationStatus status,
+                                   int exit_code) OVERRIDE;
+
   // BrowserPluginGuestDelegate implementation.
   virtual void Destroy() OVERRIDE FINAL;
   virtual void DidAttach(
       content::WebContents* embedder_web_contents,
       const base::DictionaryValue& extra_params) OVERRIDE FINAL;
+  virtual int GetGuestInstanceID() const OVERRIDE;
   virtual void RegisterDestructionCallback(
       const DestructionCallback& callback) OVERRIDE FINAL;
 
  protected:
   explicit GuestViewBase(int guest_instance_id);
 
   virtual ~GuestViewBase();
 
   // Dispatches an event |event_name| to the embedder with the |event| fields.
   void DispatchEvent(Event* event);
@@ skipping 45 matching lines @@
   scoped_ptr<EmbedderWebContentsObserver> embedder_web_contents_observer_;
 
   // This is used to ensure pending tasks will not fire after this object is
   // destroyed.
   base::WeakPtrFactory<GuestViewBase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GuestViewBase);
 };
 
 #endif  // CHROME_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_