Start splitting out WebUI into an implementation class and an interface that each page implements...

content/browser/webui/web_ui.h

 // Copyright (c) 2012 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 CONTENT_BROWSER_WEBUI_WEB_UI_H_
 #define CONTENT_BROWSER_WEBUI_WEB_UI_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/string16.h"
 #include "content/common/content_export.h"
 #include "content/public/common/page_transition_types.h"
 #include "ipc/ipc_channel.h"
 
 class GURL;
 class RenderViewHost;
 
 namespace base {
 class ListValue;
 class Value;
 }
 
 namespace content {
 class WebContents;
+class WebUIController;
 class WebUIMessageHandler;
 }
 
 // A WebUI sets up the datasources and message handlers for a given HTML-based
 // UI.
 //
 // NOTE: If you're creating a new WebUI for Chrome code, make sure you extend
 // ChromeWebUI.
 class CONTENT_EXPORT WebUI : public IPC::Channel::Listener {
  public:
-  explicit WebUI(content::WebContents* contents);
+  WebUI(content::WebContents* contents, content::WebUIController* controller);
   virtual ~WebUI();
 
-  // IPC message handling.
+  // IPC::Channel::Listener implementation:
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
-  virtual void OnWebUISend(const GURL& source_url,
-                           const std::string& message,
-                           const base::ListValue& args);
 
-  // Called by RenderViewHost when the RenderView is first created. This is
-  // *not* called for every page load because in some cases
-  // RenderViewHostManager will reuse RenderView instances. In those cases,
-  // RenderViewReused will be called instead.
-  virtual void RenderViewCreated(RenderViewHost* render_view_host);
-
-  // Called by RenderViewHostManager when a RenderView is reused to display a
-  // page.
-  virtual void RenderViewReused(RenderViewHost* render_view_host) {}
-
-  // Called when this becomes the active WebUI instance for a re-used
-  // RenderView; this is the point at which this WebUI instance will receive
-  // DOM messages instead of the previous WebUI instance.
-  //
-  // If a WebUI instance has code that is usually triggered from a JavaScript
-  // onload handler, this should be overridden to check to see if the web page's
-  // DOM is still intact (e.g., due to a back/forward navigation that remains
-  // within the same page), and if so trigger that code manually since onload
-  // won't be run in that case.
-  virtual void DidBecomeActiveForReusedRenderView() {}
+  // Called by TabContents when the RenderView is first created. This is *not*
+  // called for every page load because in some cases RenderViewHostManager will
+  // reuse RenderView instances.
+  void RenderViewCreated(RenderViewHost* render_view_host);
 
   // Used by WebUIMessageHandlers. If the given message is already registered,
   // the call has no effect unless |register_callback_overwrites_| is set to
   // true.
   typedef base::Callback<void(const base::ListValue*)> MessageCallback;
   void RegisterMessageCallback(const std::string& message,
                                const MessageCallback& callback);
 
   // Returns true if the favicon should be hidden for the current tab.
   bool hide_favicon() const {
@@ skipping 37 matching lines @@
   }
 
   void set_register_callback_overwrites(bool value) {
     register_callback_overwrites_ = value;
   }
 
   void set_frame_xpath(const std::string& xpath) {
     frame_xpath_ = xpath;
   }
 
+  content::WebUIController* controller() const { return controller_; }
+
   // Call a Javascript function by sending its name and arguments down to
   // the renderer.  This is asynchronous; there's no way to get the result
   // of the call, and should be thought of more like sending a message to
   // the page.
   // All function names in WebUI must consist of only ASCII characters.
   // There are variants for calls with more arguments.
   void CallJavascriptFunction(const std::string& function_name);
   void CallJavascriptFunction(const std::string& function_name,
                               const base::Value& arg);
   void CallJavascriptFunction(const std::string& function_name,
@@ skipping 47 matching lines @@
 
   // Used by test mocks. See the public getters for more information.
   bool register_callback_overwrites_;  // Defaults to false.
 
   // The WebUIMessageHandlers we own.
   std::vector<content::WebUIMessageHandler*> handlers_;
 
   // Non-owning pointer to the WebContents this WebUI is associated with.
   content::WebContents* web_contents_;
 
+  // TODO(jam): once WebUI objects aren't also WebUIController, make one own the
+  // other.
+  content::WebUIController* controller_;
+
  private:
+  // IPC message handling.
+  void OnWebUISend(const GURL& source_url,
+                   const std::string& message,
+                   const base::ListValue& args);
+
   // A map of message name -> message handling callback.
   typedef std::map<std::string, MessageCallback> MessageCallbackMap;
   MessageCallbackMap message_callbacks_;
 
   // The path for the iframe this WebUI is embedded in (empty if not in an
   // iframe).
   std::string frame_xpath_;
 
   DISALLOW_COPY_AND_ASSIGN(WebUI);
 };
 
 #endif  // CONTENT_BROWSER_WEBUI_WEB_UI_H_