Make PepperWebPlugin not use RenderViews.

extensions/browser/extension_function.h

 // Copyright 2013 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 EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 #define EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 
 #include <list>
 #include <string>
 
@@ skipping 17 matching lines @@
 class UIThreadExtensionFunction;
 class IOThreadExtensionFunction;
 
 namespace base {
 class ListValue;
 class Value;
 }
 
 namespace content {
 class BrowserContext;
+class RenderFrameHost;
 class RenderViewHost;
 class WebContents;
 }
 
 namespace extensions {
 class QuotaLimitHeuristic;
 }
 
 #ifdef NDEBUG
 #define EXTENSION_FUNCTION_VALIDATE(test) do { \
@@ skipping 235 matching lines @@
   UIThreadExtensionFunction();
 
   virtual UIThreadExtensionFunction* AsUIThreadExtensionFunction() OVERRIDE;
 
   void set_test_delegate(DelegateForTests* delegate) {
     delegate_ = delegate;
   }
 
   // Called when a message was received.
   // Should return true if it processed the message.
-  virtual bool OnMessageReceivedFromRenderView(const IPC::Message& message);
+  virtual bool OnMessageReceived(const IPC::Message& message);
 
   // Set the browser context which contains the extension that has originated
   // this function call.
   void set_context(content::BrowserContext* context) { context_ = context; }
   content::BrowserContext* context() const { return context_; }
 
   void SetRenderViewHost(content::RenderViewHost* render_view_host);
   content::RenderViewHost* render_view_host() const {
     return render_view_host_;
   }
+  void SetRenderFrameHost(content::RenderFrameHost* render_frame_host);
+  content::RenderFrameHost* render_frame_host() const {
+    return render_frame_host_;
+  }
 
   void set_dispatcher(
       const base::WeakPtr<ExtensionFunctionDispatcher>& dispatcher) {
     dispatcher_ = dispatcher;
   }
   ExtensionFunctionDispatcher* dispatcher() const {
     return dispatcher_.get();
   }
 
   // Gets the "current" web contents if any. If there is no associated web
@@ skipping 12 matching lines @@
   virtual ~UIThreadExtensionFunction();
 
   virtual void SendResponse(bool success) OVERRIDE;
 
   // The dispatcher that will service this extension function call.
   base::WeakPtr<ExtensionFunctionDispatcher> dispatcher_;
 
   // The RenderViewHost we will send responses too.
   content::RenderViewHost* render_view_host_;
 
+  // The RenderFrameHost we will send responses too.

[Yoyo Zhou, 2013/12/20 00:28:37]

nit: to (here and 338)

[jam, 2013/12/20 17:00:48]

Done.

+  // NOTE: either render_view_host_ or render_frame_host_ will be set, as we
+  // port code to use RenderFrames for OOPIF. See http://crbug.com/304341.
+  content::RenderFrameHost* render_frame_host_;
+
   // The content::BrowserContext of this function's extension.
   content::BrowserContext* context_;
 
  private:
-  class RenderViewHostTracker;
+  class RenderHostTracker;
 
   virtual void Destruct() const OVERRIDE;
 
-  scoped_ptr<RenderViewHostTracker> tracker_;
+  scoped_ptr<RenderHostTracker> tracker_;
 
   DelegateForTests* delegate_;
 };
 
 // Extension functions that run on the IO thread. This type of function avoids
 // a roundtrip to and from the UI thread (because communication with the
 // extension process happens on the IO thread). It's intended to be used when
 // performance is critical (e.g. the webRequest API which can block network
 // requests). Generally, UIThreadExtensionFunction is more appropriate and will
 // be easier to use and interface with the rest of the browser.
@@ skipping 71 matching lines @@
  public:
   SyncIOThreadExtensionFunction();
 
   virtual void Run() OVERRIDE;
 
  protected:
   virtual ~SyncIOThreadExtensionFunction();
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_