Switch to WebFrame from the WebKit API....

chrome/renderer/render_view.h

 // Copyright (c) 2009 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_RENDERER_RENDER_VIEW_H_
 #define CHROME_RENDERER_RENDER_VIEW_H_
 
 #include <string>
 #include <queue>
 #include <vector>
@@ skipping 33 matching lines @@
 
 class AudioMessageFilter;
 class DictionaryValue;
 class DevToolsAgent;
 class DevToolsClient;
 class FilePath;
 class GURL;
 class ListValue;
 class NavigationState;
 class PrintWebViewHelper;
-class WebFrame;
 class WebPluginDelegate;
 class WebPluginDelegateProxy;
 class WebDevToolsAgentDelegate;
 struct ContextMenuMediaParams;
 struct ThumbnailScore;
 struct ViewMsg_ClosePage_Params;
 struct ViewMsg_Navigate_Params;
 struct ViewMsg_UploadFile_Params;
 struct WebDropData;
 
@@ skipping 69 matching lines @@
   }
 
   // IPC::Channel::Listener
   virtual void OnMessageReceived(const IPC::Message& msg);
 
   // WebViewDelegate
   virtual bool CanAcceptLoadDrops() const;
   virtual void ShowModalHTMLDialog(const GURL& url, int width, int height,
                                    const std::string& json_arguments,
                                    std::string* json_retval);
-  virtual void RunJavaScriptAlert(WebFrame* webframe,
+  virtual void RunJavaScriptAlert(WebKit::WebFrame* webframe,
                                   const std::wstring& message);
-  virtual bool RunJavaScriptConfirm(WebFrame* webframe,
+  virtual bool RunJavaScriptConfirm(WebKit::WebFrame* webframe,
                                     const std::wstring& message);
-  virtual bool RunJavaScriptPrompt(WebFrame* webframe,
+  virtual bool RunJavaScriptPrompt(WebKit::WebFrame* webframe,
                                    const std::wstring& message,
                                    const std::wstring& default_value,
                                    std::wstring* result);
-  virtual bool RunBeforeUnloadConfirm(WebFrame* webframe,
+  virtual bool RunBeforeUnloadConfirm(WebKit::WebFrame* webframe,
                                       const std::wstring& message);
   virtual void QueryFormFieldAutofill(const std::wstring& field_name,
                                       const std::wstring& text,
                                       int64 node_id);
   virtual void RemoveStoredAutofillEntry(const std::wstring& field_name,
                                          const std::wstring& text);
   virtual void UpdateTargetURL(WebView* webview,
                                const GURL& url);
   virtual void RunFileChooser(bool multi_select,
                               const string16& title,
                               const FilePath& initial_filename,
                               WebFileChooserCallback* file_chooser);
   virtual void AddMessageToConsole(WebView* webview,
                                    const std::wstring& message,
                                    unsigned int line_no,
                                    const std::wstring& source_id);
 
   virtual void DidStartLoading(WebView* webview);
   virtual void DidStopLoading(WebView* webview);
-  virtual void DidCreateDataSource(WebFrame* frame, WebKit::WebDataSource* ds);
+  virtual void DidCreateDataSource(WebKit::WebFrame* frame,
+                                   WebKit::WebDataSource* ds);
   virtual void DidStartProvisionalLoadForFrame(
       WebView* webview,
-      WebFrame* frame,
+      WebKit::WebFrame* frame,
       NavigationGesture gesture);
   virtual void DidReceiveProvisionalLoadServerRedirect(WebView* webview,
-                                                       WebFrame* frame);
+                                                       WebKit::WebFrame* frame);
   virtual void DidFailProvisionalLoadWithError(
       WebView* webview,
       const WebKit::WebURLError& error,
-      WebFrame* frame);
+      WebKit::WebFrame* frame);
   virtual void LoadNavigationErrorPage(
-      WebFrame* frame,
+      WebKit::WebFrame* frame,
       const WebKit::WebURLRequest& failed_request,
       const WebKit::WebURLError& error,
       const std::string& html,
       bool replace);
-  virtual void DidReceiveDocumentData(WebFrame* frame, const char* data,
+  virtual void DidReceiveDocumentData(WebKit::WebFrame* frame, const char* data,
                                       size_t data_len);
-  virtual void DidCommitLoadForFrame(WebView* webview, WebFrame* frame,
+  virtual void DidCommitLoadForFrame(WebView* webview, WebKit::WebFrame* frame,
                                      bool is_new_navigation);
   virtual void DidReceiveTitle(WebView* webview,
                                const std::wstring& title,
-                               WebFrame* frame);
+                               WebKit::WebFrame* frame);
   virtual void DidFinishLoadForFrame(WebView* webview,
-                                     WebFrame* frame);
+                                     WebKit::WebFrame* frame);
   virtual void DidFailLoadWithError(WebView* webview,
                                     const WebKit::WebURLError& error,
-                                    WebFrame* forFrame);
-  virtual void DidFinishDocumentLoadForFrame(WebView* webview, WebFrame* frame);
+                                    WebKit::WebFrame* forFrame);
+  virtual void DidFinishDocumentLoadForFrame(WebView* webview, WebKit::WebFrame* frame);
   virtual bool DidLoadResourceFromMemoryCache(
       WebView* webview,
       const WebKit::WebURLRequest& request,
       const WebKit::WebURLResponse& response,
-      WebFrame* frame);
-  virtual void DidHandleOnloadEventsForFrame(WebView* webview, WebFrame* frame);
+      WebKit::WebFrame* frame);
+  virtual void DidHandleOnloadEventsForFrame(WebView* webview, WebKit::WebFrame* frame);
   virtual void DidChangeLocationWithinPageForFrame(WebView* webview,
-                                                   WebFrame* frame,
+                                                   WebKit::WebFrame* frame,
                                                    bool is_new_navigation);
   virtual void DidContentsSizeChange(WebKit::WebWidget* webwidget,
                                      int new_width,
                                      int new_height);
 
   virtual void DidCompleteClientRedirect(WebView* webview,
-                                         WebFrame* frame,
+                                         WebKit::WebFrame* frame,
                                          const GURL& source);
-  virtual void WillCloseFrame(WebView* webview, WebFrame* frame);
-  virtual void WillSubmitForm(WebView* webview, WebFrame* frame,
+  virtual void WillCloseFrame(WebView* webview, WebKit::WebFrame* frame);
+  virtual void WillSubmitForm(WebView* webview, WebKit::WebFrame* frame,
                               const WebKit::WebForm& form);
-  virtual void WillSendRequest(WebFrame* webframe,
+  virtual void WillSendRequest(WebKit::WebFrame* webframe,
                                uint32 identifier,
                                WebKit::WebURLRequest* request,
                                const WebKit::WebURLResponse& redirect_response);
-  virtual void DidReceiveResponse(WebFrame* webframe,
+  virtual void DidReceiveResponse(WebKit::WebFrame* webframe,
                                   uint32 identifier,
                                   const WebKit::WebURLResponse& response);
-  virtual void DidFinishLoading(WebFrame* webframe, uint32 identifier);
+  virtual void DidFinishLoading(WebKit::WebFrame* webframe, uint32 identifier);
 
-  virtual void WindowObjectCleared(WebFrame* webframe);
-  virtual void DocumentElementAvailable(WebFrame* webframe);
-  virtual void DidCreateScriptContextForFrame(WebFrame* webframe);
-  virtual void DidDestroyScriptContextForFrame(WebFrame* webframe);
-  virtual void DidCreateIsolatedScriptContext(WebFrame* webframe);
+  virtual void WindowObjectCleared(WebKit::WebFrame* webframe);
+  virtual void DocumentElementAvailable(WebKit::WebFrame* webframe);
+  virtual void DidCreateScriptContextForFrame(WebKit::WebFrame* webframe);
+  virtual void DidDestroyScriptContextForFrame(WebKit::WebFrame* webframe);
+  virtual void DidCreateIsolatedScriptContext(WebKit::WebFrame* webframe);
 
   virtual WebKit::WebNavigationPolicy PolicyForNavigationAction(
       WebView* webview,
-      WebFrame* frame,
+      WebKit::WebFrame* frame,
       const WebKit::WebURLRequest& request,
       WebKit::WebNavigationType type,
       WebKit::WebNavigationPolicy default_policy,
       bool is_redirect);
 
   virtual WebView* CreateWebView(WebView* webview,
                                  bool user_gesture,
                                  const GURL& creator_url);
   virtual WebKit::WebWidget* CreatePopupWidget(
       WebView* webview,
@@ skipping 64 matching lines @@
                                          int active_match_ordinal,
                                          const WebKit::WebRect& selection);
   virtual bool WasOpenedByUserGesture() const;
   virtual void FocusAccessibilityObject(WebCore::AccessibilityObject* acc_obj);
   virtual void DidMovePlugin(const WebPluginGeometry& move);
   virtual void WillDestroyPluginWindow(gfx::PluginWindowHandle handle);
   virtual void SpellCheck(const std::wstring& word, int* misspell_location,
                           int* misspell_length);
   virtual std::wstring GetAutoCorrectWord(const std::wstring& word);
   virtual void SetInputMethodState(bool enabled);
-  virtual void ScriptedPrint(WebFrame* frame);
+  virtual void ScriptedPrint(WebKit::WebFrame* frame);
   virtual void UserMetricsRecordAction(const std::wstring& action);
   virtual void DnsPrefetch(const std::vector<std::string>& host_names);
 
   // DomSerializerDelegate
   virtual void DidSerializeDataForFrame(const GURL& frame_url,
       const std::string& data, PageSavingSerializationStatus status);
 
   // WebKit::WebWidgetClient
   // Most methods are handled by RenderWidget.
   virtual void show(WebKit::WebNavigationPolicy policy);
@@ skipping 72 matching lines @@
   // set to 'MSG_ROUTING_NONE' if the true ID is not yet known. In this case,
   // CompleteInit must be called later with the true ID.
   void Init(gfx::NativeViewId parent,
             base::WaitableEvent* modal_dialog_event,  // takes ownership
             int32 opener_id,
             const RendererPreferences& renderer_prefs,
             const WebPreferences& webkit_prefs,
             SharedRenderViewCounter* counter,
             int32 routing_id);
 
-  void UpdateURL(WebFrame* frame);
-  void UpdateTitle(WebFrame* frame, const std::wstring& title);
-  void UpdateSessionHistory(WebFrame* frame);
+  void UpdateURL(WebKit::WebFrame* frame);
+  void UpdateTitle(WebKit::WebFrame* frame, const std::wstring& title);
+  void UpdateSessionHistory(WebKit::WebFrame* frame);
 
   // Update current main frame's encoding and send it to browser window.
   // Since we want to let users see the right encoding info from menu
   // before finishing loading, we call the UpdateEncoding in
   // a) function:DidCommitLoadForFrame. When this function is called,
   // that means we have got first data. In here we try to get encoding
   // of page if it has been specified in http header.
   // b) function:DidReceiveTitle. When this function is called,
   // that means we have got specified title. Because in most of webpages,
   // title tags will follow meta tags. In here we try to get encoding of
   // page if it has been specified in meta tag.
   // c) function:DidFinishDocumentLoadForFrame. When this function is
   // called, that means we have got whole html page. In here we should
   // finally get right encoding of page.
-  void UpdateEncoding(WebFrame* frame, const std::wstring& encoding_name);
+  void UpdateEncoding(WebKit::WebFrame* frame, const std::wstring& encoding_name);
 
   // Captures the thumbnail and text contents for indexing for the given load
   // ID. If the view's load ID is different than the parameter, this call is
   // a NOP. Typically called on a timer, so the load ID may have changed in the
   // meantime.
   void CapturePageInfo(int load_id, bool preliminary_capture);
 
   // Called to retrieve the text from the given frame contents, the page text
   // up to the maximum amount will be placed into the given buffer
-  void CaptureText(WebFrame* frame, std::wstring* contents);
+  void CaptureText(WebKit::WebFrame* frame, std::wstring* contents);
 
   // Creates a thumbnail of |frame|'s contents resized to (|w|, |h|)
   // and puts that in |thumbnail|. Thumbnail metadata goes in |score|.
   bool CaptureThumbnail(WebView* view, int w, int h,
                         SkBitmap* thumbnail,
                         ThumbnailScore* score);
 
   // Calculates how "boring" a thumbnail is. The boring score is the
   // 0,1 ranged percentage of pixels that are the most common
   // luma. Higher boring scores indicate that a higher percentage of a
@@ skipping 145 matching lines @@
   // Attempt to upload the file that we are trying to process if any.
   // Reset the pending file upload data if the form was successfully
   // posted.
   void ProcessPendingUpload();
 
   // Reset the pending file upload.
   void ResetPendingUpload();
 
   // Exposes the DOMAutomationController object that allows JS to send
   // information to the browser process.
-  void BindDOMAutomationController(WebFrame* webframe);
+  void BindDOMAutomationController(WebKit::WebFrame* webframe);
 
   // Creates DevToolsClient and sets up JavaScript bindings for developer tools
   // UI that is going to be hosted by this RenderView.
   void CreateDevToolsClient();
 
   // Locates a sub frame with given xpath
-  WebFrame* GetChildFrame(const std::wstring& frame_xpath) const;
+  WebKit::WebFrame* GetChildFrame(const std::wstring& frame_xpath) const;
 
   enum ErrorPageType {
     DNS_ERROR,
     HTTP_404,
     CONNECTION_ERROR,
   };
 
   // Alternate error page helpers.
   GURL GetAlternateErrorPageURL(
       const GURL& failed_url, ErrorPageType error_type);
   bool MaybeLoadAlternateErrorPage(
-      WebFrame* frame, const WebKit::WebURLError& error, bool replace);
+      WebKit::WebFrame* frame, const WebKit::WebURLError& error, bool replace);
   std::string GetAltHTMLForTemplate(
       const DictionaryValue& error_strings, int template_resource_id) const;
   void AltErrorPageFinished(
-      WebFrame* frame, const WebKit::WebURLError& original_error,
+      WebKit::WebFrame* frame, const WebKit::WebURLError& original_error,
       const std::string& html);
 
   virtual void DidAddHistoryItem();
 
   // Decodes a data: URL image or returns an empty image in case of failure.
   SkBitmap ImageFromDataUrl(const GURL&) const;
 
   void DumpLoadHistograms() const;
 
   // Scan the given frame for password forms and send them up to the browser.
-  void SendPasswordForms(WebFrame* frame);
+  void SendPasswordForms(WebKit::WebFrame* frame);
 
-  void Print(WebFrame* frame, bool script_initiated);
+  void Print(WebKit::WebFrame* frame, bool script_initiated);
 
 #if defined(OS_LINUX)
   void UpdateFontRenderingFromRendererPrefs();
 #else
   void UpdateFontRenderingFromRendererPrefs() { }
 #endif
 
   // Bitwise-ORed set of extra bindings that have been enabled.  See
   // BindingsPolicy for details.
   int enabled_bindings_;
@@ skipping 181 matching lines @@
 
   RendererPreferences renderer_preferences_;
 
   // page id for the last navigation sent to the browser.
   int32 last_top_level_navigation_page_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderView);
 };
 
 #endif  // CHROME_RENDERER_RENDER_VIEW_H_