Flesh out more of ChromiumBridge.cpp eliminating all but two methods on...

webkit/api/src/ChromiumBridge.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "ChromiumBridge.h"
 
 #include <googleurl/src/url_util.h>
 
+#include "ChromeClientImpl.h"
 #include "WebClipboard.h"
 #include "WebCookie.h"
+#include "WebCursorInfo.h"
 #include "WebData.h"
+#include "WebFrameClient.h"
+#include "WebFrameImpl.h"
 #include "WebImage.h"
 #include "WebKit.h"
 #include "WebKitClient.h"
 #include "WebMimeRegistry.h"
 #include "WebPluginContainerImpl.h"
 #include "WebPluginListBuilderImpl.h"
+#include "WebScreenInfo.h"
 #include "WebString.h"
 #include "WebVector.h"
 #include "WebURL.h"
-#include "Worker.h"
-#include "WorkerContextProxy.h"
+#include "WebViewClient.h"
+#include "WebViewImpl.h"
+#include "WebWorkerClientImpl.h"
 
 #if PLATFORM(WIN_OS)
 #include "WebRect.h"
 #include "WebSandboxSupport.h"
 #include "WebThemeEngine.h"
 #endif
 
 #if PLATFORM(LINUX)
 #include "WebSandboxSupport.h"
 #include "WebFontInfo.h"
 #endif
 
 #if WEBKIT_USING_SKIA
 #include "NativeImageSkia.h"
 #endif
 
 #include "BitmapImage.h"
 #include "Cookie.h"
 #include "GraphicsContext.h"
 #include "KURL.h"
+#include "FrameView.h"
 #include "NotImplemented.h"
 #include "PlatformContextSkia.h"
 #include "PluginData.h"
+#include "Worker.h"
+#include "WorkerContextProxy.h"
 #include <wtf/Assertions.h>
 
 // We are part of the WebKit implementation.
 using namespace WebKit;
 
 namespace WebCore {
 
+static ChromeClientImpl* toChromeClientImpl(Widget* widget)
+{
+    FrameView* view;
+    if (widget->isFrameView())
+        view = static_cast<FrameView*>(widget);
+    else if (widget->parent() && widget->parent()->isFrameView())
+        view = static_cast<FrameView*>(widget->parent());
+    else
+        return 0;
+
+    Page* page = view->frame() ? view->frame()->page() : 0;
+    if (!page)
+        return 0;
+
+    return static_cast<ChromeClientImpl*>(page->chrome()->client());
+}
+
+static WebWidgetClient* toWebWidgetClient(Widget* widget)
+{
+    ChromeClientImpl* chromeClientImpl = toChromeClientImpl(widget);
+    if (!chromeClientImpl || !chromeClientImpl->webView())
+        return 0;
+    return chromeClientImpl->webView()->client();
+}
+
 // Clipboard ------------------------------------------------------------------
 
 bool ChromiumBridge::clipboardIsFormatAvailable(
     PasteboardPrivate::ClipboardFormat format,
     PasteboardPrivate::ClipboardBuffer buffer)
 {
     return webKitClient()->clipboard()->isFormatAvailable(
         static_cast<WebClipboard::Format>(format),
         static_cast<WebClipboard::Buffer>(buffer));
 }
@@ skipping 268 matching lines @@
 bool ChromiumBridge::plugins(bool refresh, Vector<PluginInfo*>* results)
 {
     WebPluginListBuilderImpl builder(results);
     webKitClient()->getPluginList(refresh, &builder);
     return true;  // FIXME: There is no need for this function to return a value.
 }
 
 NPObject* ChromiumBridge::pluginScriptableObject(Widget* widget)
 {
     if (!widget)
-        return NULL;
+        return 0;
 
     ASSERT(!widget->isFrameView());
 
     // NOTE:  We have to trust that the widget passed to us here is a
     // WebPluginContainerImpl.  There isn't a way to dynamically verify it,
     // since the derived class (Widget) has no identifier.
     return static_cast<WebPluginContainerImpl*>(widget)->scriptableObject();
 }
 
 // Resources ------------------------------------------------------------------
@@ skipping 134 matching lines @@
     webKitClient()->traceEventBegin(name, id, extra);
 }
 
 void ChromiumBridge::traceEventEnd(const char* name, void* id, const char* extra)
 {
     webKitClient()->traceEventEnd(name, id, extra);
 }
 
 // Visited Links --------------------------------------------------------------
 
-WebCore::LinkHash ChromiumBridge::visitedLinkHash(const UChar* url,
-                                                  unsigned length)
+LinkHash ChromiumBridge::visitedLinkHash(const UChar* url, unsigned length)
 {
     url_canon::RawCanonOutput<2048> buffer;
     url_parse::Parsed parsed;
-    if (!url_util::Canonicalize(url, length, NULL, &buffer, &parsed))
+    if (!url_util::Canonicalize(url, length, 0, &buffer, &parsed))
         return 0;  // Invalid URLs are unvisited.
     return webKitClient()->visitedLinkHash(buffer.data(), buffer.length());
 }
 
-WebCore::LinkHash ChromiumBridge::visitedLinkHash(const WebCore::KURL& base,
-                                                  const WebCore::AtomicString& attributeURL)
+LinkHash ChromiumBridge::visitedLinkHash(const KURL& base,
+                                         const AtomicString& attributeURL)
 {
     // Resolve the relative URL using googleurl and pass the absolute URL up to
     // the embedder. We could create a GURL object from the base and resolve
     // the relative URL that way, but calling the lower-level functions
     // directly saves us the string allocation in most cases.
     url_canon::RawCanonOutput<2048> buffer;
     url_parse::Parsed parsed;
 
 #if USE(GOOGLEURL)
-    const WebCore::CString& cstr = base.utf8String();
+    const CString& cstr = base.utf8String();
     const char* data = cstr.data();
     int length = cstr.length();
     const url_parse::Parsed& srcParsed = base.parsed();
 #else
     // When we're not using GoogleURL, first canonicalize it so we can resolve it
     // below.
     url_canon::RawCanonOutput<2048> srcCanon;
     url_parse::Parsed srcParsed;
-    WebCore::String str = base.string();
-    if (!url_util::Canonicalize(str.characters(), str.length(), NULL, &srcCanon, &srcParsed))
+    String str = base.string();
+    if (!url_util::Canonicalize(str.characters(), str.length(), 0, &srcCanon, &srcParsed))
         return 0;
     const char* data = srcCanon.data();
     int length = srcCanon.length();
 #endif
 
     if (!url_util::ResolveRelative(data, length, srcParsed, attributeURL.characters(),
-                                   attributeURL.length(), NULL, &buffer, &parsed))
+                                   attributeURL.length(), 0, &buffer, &parsed))
         return 0;  // Invalid resolved URL.
 
     return webKitClient()->visitedLinkHash(buffer.data(), buffer.length());
 }
 
-bool ChromiumBridge::isLinkVisited(WebCore::LinkHash visitedLinkHash)
+bool ChromiumBridge::isLinkVisited(LinkHash visitedLinkHash)
 {
     return webKitClient()->isLinkVisited(visitedLinkHash);
 }
 
 // These are temporary methoeds that the WebKit layer can use to call to the
 // Glue layer. Once the Glue layer moves entirely into the WebKit layer, these
 // methods will be deleted.
 
 String ChromiumBridge::uiResourceProtocol()
 {
     return webKitClient()->uiResourceProtocol();
 }
 
-void ChromiumBridge::notifyJSOutOfMemory(WebCore::Frame* frame)
+void ChromiumBridge::notifyJSOutOfMemory(Frame* frame)
 {
-    return webKitClient()->notifyJSOutOfMemory(frame);
+    if (!frame)
+        return;
+
+    WebFrameImpl* webFrame = WebFrameImpl::fromFrame(frame);
+    if (!webFrame->client())
+        return;
+    webFrame->client()->didExhaustMemoryAvailableForScript(webFrame);
 }
 
 int ChromiumBridge::screenDepth(Widget* widget)
 {
-    return webKitClient()->screenDepth(widget);
+    WebWidgetClient* client = toWebWidgetClient(widget);
+    if (!client)
+        return 0;
+    return client->screenInfo().depth;
 }
 
 int ChromiumBridge::screenDepthPerComponent(Widget* widget)
 {
-    return webKitClient()->screenDepthPerComponent(widget);
+    WebWidgetClient* client = toWebWidgetClient(widget);
+    if (!client)
+        return 0;
+    return client->screenInfo().depthPerComponent;
 }
 
 bool ChromiumBridge::screenIsMonochrome(Widget* widget)
 {
-    return webKitClient()->screenIsMonochrome(widget);
+    WebWidgetClient* client = toWebWidgetClient(widget);
+    if (!client)
+        return 0;
+    return client->screenInfo().isMonochrome;
 }
 
 IntRect ChromiumBridge::screenRect(Widget* widget)
 {
-    return webKitClient()->screenRect(widget);
+    WebWidgetClient* client = toWebWidgetClient(widget);
+    if (!client)
+        return IntRect();
+    return client->screenInfo().rect;
 }
 
 IntRect ChromiumBridge::screenAvailableRect(Widget* widget)
 {
-    return webKitClient()->screenAvailableRect(widget);
+    WebWidgetClient* client = toWebWidgetClient(widget);
+    if (!client)
+        return IntRect();
+    return client->screenInfo().availableRect;
 }
 
 bool ChromiumBridge::popupsAllowed(NPP npp)
 {
     return webKitClient()->popupsAllowed(npp);
 }
 
 void ChromiumBridge::widgetSetCursor(Widget* widget, const Cursor& cursor)
 {
-    return webKitClient()->widgetSetCursor(widget, cursor);
+    ChromeClientImpl* client = toChromeClientImpl(widget);
+    if (client)
+        client->setCursor(WebCursorInfo(cursor));
 }
 
 void ChromiumBridge::widgetSetFocus(Widget* widget)
 {
-    return webKitClient()->widgetSetFocus(widget);
+    ChromeClientImpl* client = toChromeClientImpl(widget);
+    if (client)
+        client->focus();
 }
 
 WorkerContextProxy* WorkerContextProxy::create(Worker* worker)
 {
-    return webKitClient()->createWorkerContextProxy(worker);
+    return WebWorkerClientImpl::createWorkerContextProxy(worker);
 }
 
 } // namespace WebCore