Revert of Framework for converting embedder uses of WebFrame to WebLocalFrame.

Revert of Framework for converting embedder uses of WebFrame to WebLocalFrame. (https://codereview.chromium.org/191003006/)

Reason for revert:
This is believed to break the Mac 64-bit build.  jar just rolled back the Blink roll in an attempt to fix it.

https://codereview.chromium.org/208393010/

Original issue's description:
> Framework for converting embedder uses of WebFrame to WebLocalFrame.
> 
> This patch adds a typedef for WebFrame so we can start converting
> references to WebFrame in embedder implementations. It also updates most
> references of WebFrame in the embedding API to WebLocalFrame instead.
> Most locations should only ever have to handle WebLocalFrames, so it's
> just a fairly straightforward rename. However, there are some corner
> cases that need to be adjusted more carefully, since things like the
> opener, parent frame, and child frames can be pointers to an eventual
> WebRemoteFrame class.
> 
> BUG=346764
> 
> Committed: https://src.chromium.org/viewvc/blink?view=rev&revision=169638

TBR=abarth@chromium.org,viettrungluu@chromium.org,dcheng@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=346764, 355388

[eseidel, 2014-03-24 01:35:01]

Created Revert of Framework for converting embedder uses of WebFrame to
WebLocalFrame.

[commit-bot: I haz the power, 2014-03-24 01:35:05]

CQ is trying da patch. Follow status at
https://chromium-status.appspot.com/cq/eseidel@chromium.org/208393012/1

[commit-bot: I haz the power, 2014-03-24 01:35:14]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2014-03-24 01:35:14]

Failed to apply patch for public/web/WebFrameClient.h:
While running patch -p1 --forward --force --no-backup-if-mismatch;
  patching file public/web/WebFrameClient.h
  Hunk #2 succeeded at 57 (offset 1 line).
  Hunk #3 FAILED at 84.
  Hunk #4 succeeded at 117 (offset 4 lines).
  Hunk #5 succeeded at 125 (offset 4 lines).
  Hunk #6 succeeded at 139 (offset 4 lines).
  Hunk #7 succeeded at 161 (offset 4 lines).
  Hunk #8 succeeded at 169 (offset 4 lines).
  Hunk #9 succeeded at 249 (offset 4 lines).
  Hunk #10 succeeded at 349 (offset 4 lines).
  Hunk #11 succeeded at 361 (offset 4 lines).
  Hunk #12 succeeded at 369 (offset 4 lines).
  Hunk #13 succeeded at 377 (offset 4 lines).
  Hunk #14 succeeded at 389 (offset 4 lines).
  1 out of 14 hunks FAILED -- saving rejects to file
public/web/WebFrameClient.h.rej

Patch:       public/web/WebFrameClient.h
Index: public/web/WebFrameClient.h
diff --git a/public/web/WebFrameClient.h b/public/web/WebFrameClient.h
index
c41250c4756b368ea26f48370b2479f924094fc2..1b375b042fe57872c467dc86aa96dd106fa76282
100644
--- a/public/web/WebFrameClient.h
+++ b/public/web/WebFrameClient.h
@@ -33,7 +33,6 @@
 
 #include "WebDOMMessageEvent.h"
 #include "WebDataSource.h"
-#include "WebFrame.h"
 #include "WebIconURL.h"
 #include "WebNavigationPolicy.h"
 #include "WebNavigationType.h"
@@ -57,6 +56,7 @@
 class WebDataSource;
 class WebDOMEvent;
 class WebFormElement;
+class WebFrame;
 class WebInputEvent;
 class WebMediaPlayer;
 class WebMediaPlayerClient;
@@ -84,28 +84,28 @@
     // Factory methods -----------------------------------------------------
 
     // May return null.
-    virtual WebPlugin* createPlugin(WebLocalFrame*, const WebPluginParams&) {
return 0; }
+    virtual WebPlugin* createPlugin(WebFrame*, const WebPluginParams&) { return
0; }
 
     // May return null.
-    virtual WebMediaPlayer* createMediaPlayer(WebLocalFrame*, const WebURL&,
WebMediaPlayerClient*) { return 0; }
+    virtual WebMediaPlayer* createMediaPlayer(WebFrame*, const WebURL&,
WebMediaPlayerClient*) { return 0; }
 
     // May return null.
-    virtual WebApplicationCacheHost* createApplicationCacheHost(WebLocalFrame*,
WebApplicationCacheHostClient*) { return 0; }
+    virtual WebApplicationCacheHost* createApplicationCacheHost(WebFrame*,
WebApplicationCacheHostClient*) { return 0; }
 
     // May return null. Takes ownership of the client.
     // FIXME: Deprecate the second argument.
-    virtual WebServiceWorkerProvider*
createServiceWorkerProvider(WebLocalFrame*, WebServiceWorkerProviderClient*) {
return 0; }
-    virtual WebServiceWorkerProvider*
createServiceWorkerProvider(WebLocalFrame* frame) { return
createServiceWorkerProvider(frame, 0); }
+    virtual WebServiceWorkerProvider* createServiceWorkerProvider(WebFrame*,
WebServiceWorkerProviderClient*) { return 0; }
+    virtual WebServiceWorkerProvider* createServiceWorkerProvider(WebFrame*
frame) { return createServiceWorkerProvider(frame, 0); }
 
     // May return null.
-    virtual WebWorkerPermissionClientProxy*
createWorkerPermissionClientProxy(WebLocalFrame*) { return 0; }
+    virtual WebWorkerPermissionClientProxy*
createWorkerPermissionClientProxy(WebFrame*) { return 0; }
 
 
     // Services ------------------------------------------------------------
 
     // A frame specific cookie jar.  May return null, in which case
     // WebKitPlatformSupport::cookieJar() will be called to access cookies.
-    virtual WebCookieJar* cookieJar(WebLocalFrame*) { return 0; }
+    virtual WebCookieJar* cookieJar(WebFrame*) { return 0; }
 
 
     // General notifications -----------------------------------------------
@@ -113,7 +113,7 @@
     // Indicates that another page has accessed the DOM of the initial empty
     // document of a main frame. After this, it is no longer safe to show a
     // pending navigation's URL, because a URL spoof is possible.
-    virtual void didAccessInitialDocument(WebLocalFrame*) { }
+    virtual void didAccessInitialDocument(WebFrame*) { }
 
     // A child frame was created in this frame. This is called when the frame
     // is created and initialized. Takes the name of the new frame, the parent
@@ -121,11 +121,11 @@
     // until frameDetached() is called on it.
     // Note: If you override this, you should almost certainly be overriding
     // frameDetached().
-    virtual WebFrame* createChildFrame(WebLocalFrame* parent, const WebString&
frameName) { return 0; }
+    virtual WebFrame* createChildFrame(WebFrame* parent, const WebString&
frameName) { return 0; }
 
     // This frame set its opener to null, disowning it.
     // See http://html.spec.whatwg.org/#dom-opener.
-    virtual void didDisownOpener(WebLocalFrame*) { }
+    virtual void didDisownOpener(WebFrame*) { }
 
     // This frame has been detached from the view, but has not been closed yet.
     virtual void frameDetached(WebFrame*) { }
@@ -135,21 +135,21 @@
 
     // This frame is about to be closed. This is called after frameDetached,
     // when the document is being unloaded, due to new one committing.
-    virtual void willClose(WebLocalFrame*) { }
+    virtual void willClose(WebFrame*) { }
 
     // This frame's name has changed.
-    virtual void didChangeName(WebLocalFrame*, const WebString&) { }
+    virtual void didChangeName(WebFrame*, const WebString&) { }
 
     // Called when a watched CSS selector matches or stops matching.
-    virtual void didMatchCSS(WebLocalFrame*, const WebVector<WebString>&
newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) {
}
+    virtual void didMatchCSS(WebFrame*, const WebVector<WebString>&
newlyMatchingSelectors, const WebVector<WebString>& stoppedMatchingSelectors) {
}
 
     // Load commands -------------------------------------------------------
 
     // The client should handle the navigation externally.
     virtual void loadURLExternally(
-        WebLocalFrame*, const WebURLRequest&, WebNavigationPolicy) { }
+        WebFrame*, const WebURLRequest&, WebNavigationPolicy) { }
     virtual void loadURLExternally(
-        WebLocalFrame*, const WebURLRequest&, WebNavigationPolicy, const
WebString& downloadName) { }
+        WebFrame*, const WebURLRequest&, WebNavigationPolicy, const WebString&
downloadName) { }
 
 
     // Navigational queries ------------------------------------------------
@@ -157,7 +157,7 @@
     // The client may choose to alter the navigation policy.  Otherwise,
     // defaultPolicy should just be returned.
     virtual WebNavigationPolicy decidePolicyForNavigation(
-        WebLocalFrame*, WebDataSource::ExtraData*, const WebURLRequest&,
WebNavigationType,
+        WebFrame*, WebDataSource::ExtraData*, const WebURLRequest&,
WebNavigationType,
         WebNavigationPolicy defaultPolicy, bool isRedirect) { return
defaultPolicy; }
 
 
@@ -165,64 +165,64 @@
 
     // A form submission has been requested, but the page's submit event
handler
     // hasn't yet had a chance to run (and possibly alter/interrupt the
submit.)
-    virtual void willSendSubmitEvent(WebLocalFrame*, const WebFormElement&) { }
+    virtual void willSendSubmitEvent(WebFrame*, const WebFormElement&) { }
 
     // A form submission is about to occur.
-    virtual void willSubmitForm(WebLocalFrame*, const WebFormElement&) { }
+    virtual void willSubmitForm(WebFrame*, const WebFormElement&) { }
 
     // A datasource has been created for a new navigation.  The given
     // datasource will become the provisional datasource for the frame.
-    virtual void didCreateDataSource(WebLocalFrame*, WebDataSource*) { }
+    virtual void didCreateDataSource(WebFrame*, WebDataSource*) { }
 
     // A new provisional load has been started.
-    virtual void didStartProvisionalLoad(WebLocalFrame*) { }
+    virtual void didStartProvisionalLoad(WebFrame*) { }
 
     // The provisional load was redirected via a HTTP 3xx response.
-    virtual void didReceiveServerRedirectForProvisionalLoad(WebLocalFrame*) { }
+    virtual void didReceiveServerRedirectForProvisionalLoad(WebFrame*) { }
 
     // The provisional load failed.
-    virtual void didFailProvisionalLoad(WebLocalFrame*, const WebURLError&) { }
+    virtual void didFailProvisionalLoad(WebFrame*, const WebURLError&) { }
 
     // The provisional datasource is now committed.  The first part of the
     // response body has been received, and the encoding of the response
     // body is known.
-    virtual void didCommitProvisionalLoad(WebLocalFrame*, bool isNewNavigation)
{ }
+    virtual void didCommitProvisionalLoad(WebFrame*, bool isNewNavigation) { }
 
     // The window object for the frame has been cleared of any extra
     // properties that may have been set by script from the previously
     // loaded document.
-    virtual void didClearWindowObject(WebLocalFrame* frame, int worldId) { }
+    virtual void didClearWindowObject(WebFrame* frame, int worldId) { }
 
     // The document element has been created.
-    virtual void didCreateDocumentElement(WebLocalFrame*) { }
+    virtual void didCreateDocumentElement(WebFrame*) { }
 
     // The page title is available.
-    virtual void didReceiveTitle(WebLocalFrame* frame, const WebString& title,
WebTextDirection direction) { }
+    virtual void didReceiveTitle(WebFrame* frame, const WebString& title,
WebTextDirection direction) { }
 
     // The icon for the page have changed.
-    virtual void didChangeIcon(WebLocalFrame*, WebIconURL::Type) { }
+    virtual void didChangeIcon(WebFrame*, WebIconURL::Type) { }
 
     // The frame's document finished loading.
-    virtual void didFinishDocumentLoad(WebLocalFrame*) { }
+    virtual void didFinishDocumentLoad(WebFrame*) { }
 
     // The 'load' event was dispatched.
-    virtual void didHandleOnloadEvents(WebLocalFrame*) { }
+    virtual void didHandleOnloadEvents(WebFrame*) { }
 
     // The frame's document or one of its subresources failed to load.
-    virtual void didFailLoad(WebLocalFrame*, const WebURLError&) { }
+…
(message too large)

[dcheng, 2014-03-24 01:51:01]

This is going to be painful to revert and to reland. Are there any Mac experts
around which can help with this?