Home | History | Annotate | Download | only in web 
      1 /*
      2  * Copyright (C) 2009 Google Inc. All rights reserved.
      3  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions are
      7  * met:
      8  *
      9  *     * Redistributions of source code must retain the above copyright
     10  * notice, this list of conditions and the following disclaimer.
     11  *     * Redistributions in binary form must reproduce the above
     12  * copyright notice, this list of conditions and the following disclaimer
     13  * in the documentation and/or other materials provided with the
     14  * distribution.
     15  *     * Neither the name of Google Inc. nor the names of its
     16  * contributors may be used to endorse or promote products derived from
     17  * this software without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include "config.h"
     33 #include "ChromeClientImpl.h"
     34 
     35 #include "ColorChooserPopupUIController.h"
     36 #include "ColorChooserUIController.h"
     37 #include "DateTimeChooserImpl.h"
     38 #include "ExternalDateTimeChooser.h"
     39 #include "ExternalPopupMenu.h"
     40 #include "HTMLNames.h"
     41 #include "PopupContainer.h"
     42 #include "PopupMenuChromium.h"
     43 #include "RuntimeEnabledFeatures.h"
     44 #include "WebAccessibilityObject.h"
     45 #include "WebAutofillClient.h"
     46 #include "WebColorChooser.h"
     47 #include "WebConsoleMessage.h"
     48 #include "WebCursorInfo.h"
     49 #include "WebFileChooserCompletionImpl.h"
     50 #include "WebFrameClient.h"
     51 #include "WebFrameImpl.h"
     52 #include "WebInputElement.h"
     53 #include "WebInputEvent.h"
     54 #include "WebKit.h"
     55 #include "WebNode.h"
     56 #include "WebPasswordGeneratorClient.h"
     57 #include "WebPlugin.h"
     58 #include "WebPluginContainerImpl.h"
     59 #include "WebPopupMenuImpl.h"
     60 #include "WebPopupMenuInfo.h"
     61 #include "WebPopupType.h"
     62 #include "WebSettings.h"
     63 #include "WebSettingsImpl.h"
     64 #include "WebTextDirection.h"
     65 #include "WebUserGestureIndicator.h"
     66 #include "WebUserGestureToken.h"
     67 #include "WebViewClient.h"
     68 #include "WebViewImpl.h"
     69 #include "WebWindowFeatures.h"
     70 #include "bindings/v8/ScriptController.h"
     71 #include "core/accessibility/AXObjectCache.h"
     72 #include "core/accessibility/AccessibilityObject.h"
     73 #include "core/dom/Document.h"
     74 #include "core/dom/Node.h"
     75 #include "core/html/HTMLInputElement.h"
     76 #include "core/loader/DocumentLoader.h"
     77 #include "core/loader/FrameLoadRequest.h"
     78 #include "core/loader/NavigationAction.h"
     79 #include "core/page/Console.h"
     80 #include "core/page/FrameView.h"
     81 #include "core/page/Page.h"
     82 #include "core/page/PagePopupDriver.h"
     83 #include "core/page/Settings.h"
     84 #include "core/page/WindowFeatures.h"
     85 #include "core/platform/ColorChooser.h"
     86 #include "core/platform/ColorChooserClient.h"
     87 #include "core/platform/Cursor.h"
     88 #include "core/platform/DateTimeChooser.h"
     89 #include "core/platform/FileChooser.h"
     90 #include "core/platform/PlatformScreen.h"
     91 #include "core/platform/chromium/support/WrappedResourceRequest.h"
     92 #include "core/platform/graphics/FloatRect.h"
     93 #include "core/platform/graphics/GraphicsLayer.h"
     94 #include "core/platform/graphics/IntRect.h"
     95 #include "core/rendering/HitTestResult.h"
     96 #include "core/rendering/RenderWidget.h"
     97 #include "modules/geolocation/Geolocation.h"
     98 #include "public/platform/Platform.h"
     99 #include "public/platform/WebRect.h"
    100 #include "public/platform/WebURLRequest.h"
    101 #include "weborigin/SecurityOrigin.h"
    102 #include "wtf/text/CString.h"
    103 #include "wtf/text/StringBuilder.h"
    104 #include "wtf/text/StringConcatenate.h"
    105 #include "wtf/unicode/CharacterNames.h"
    106 
    107 using namespace WebCore;
    108 
    109 namespace WebKit {
    110 
    111 // Converts a WebCore::PopupContainerType to a WebKit::WebPopupType.
    112 static WebPopupType convertPopupType(PopupContainer::PopupType type)
    113 {
    114     switch (type) {
    115     case PopupContainer::Select:
    116         return WebPopupTypeSelect;
    117     case PopupContainer::Suggestion:
    118         return WebPopupTypeSuggestion;
    119     default:
    120         ASSERT_NOT_REACHED();
    121         return WebPopupTypeNone;
    122     }
    123 }
    124 
    125 // Converts a WebCore::AXObjectCache::AXNotification to a WebKit::WebAccessibilityNotification
    126 static WebAccessibilityNotification toWebAccessibilityNotification(AXObjectCache::AXNotification notification)
    127 {
    128     // These enums have the same values; enforced in AssertMatchingEnums.cpp.
    129     return static_cast<WebAccessibilityNotification>(notification);
    130 }
    131 
    132 ChromeClientImpl::ChromeClientImpl(WebViewImpl* webView)
    133     : m_webView(webView)
    134     , m_toolbarsVisible(true)
    135     , m_statusbarVisible(true)
    136     , m_scrollbarsVisible(true)
    137     , m_menubarVisible(true)
    138     , m_resizable(true)
    139     , m_pagePopupDriver(webView)
    140 {
    141 }
    142 
    143 ChromeClientImpl::~ChromeClientImpl()
    144 {
    145 }
    146 
    147 void* ChromeClientImpl::webView() const
    148 {
    149     return static_cast<void*>(m_webView);
    150 }
    151 
    152 void ChromeClientImpl::chromeDestroyed()
    153 {
    154     // Our lifetime is bound to the WebViewImpl.
    155 }
    156 
    157 void ChromeClientImpl::setWindowRect(const FloatRect& r)
    158 {
    159     if (m_webView->client())
    160         m_webView->client()->setWindowRect(IntRect(r));
    161 }
    162 
    163 FloatRect ChromeClientImpl::windowRect()
    164 {
    165     WebRect rect;
    166     if (m_webView->client())
    167         rect = m_webView->client()->rootWindowRect();
    168     else {
    169         // These numbers will be fairly wrong. The window's x/y coordinates will
    170         // be the top left corner of the screen and the size will be the content
    171         // size instead of the window size.
    172         rect.width = m_webView->size().width;
    173         rect.height = m_webView->size().height;
    174     }
    175     return FloatRect(rect);
    176 }
    177 
    178 FloatRect ChromeClientImpl::pageRect()
    179 {
    180     // We hide the details of the window's border thickness from the web page by
    181     // simple re-using the window position here.  So, from the point-of-view of
    182     // the web page, the window has no border.
    183     return windowRect();
    184 }
    185 
    186 void ChromeClientImpl::focus()
    187 {
    188     if (m_webView->client())
    189         m_webView->client()->didFocus();
    190 }
    191 
    192 void ChromeClientImpl::unfocus()
    193 {
    194     if (m_webView->client())
    195         m_webView->client()->didBlur();
    196 }
    197 
    198 bool ChromeClientImpl::canTakeFocus(FocusDirection)
    199 {
    200     // For now the browser can always take focus if we're not running layout
    201     // tests.
    202     return !layoutTestMode();
    203 }
    204 
    205 void ChromeClientImpl::takeFocus(FocusDirection direction)
    206 {
    207     if (!m_webView->client())
    208         return;
    209     if (direction == FocusDirectionBackward)
    210         m_webView->client()->focusPrevious();
    211     else
    212         m_webView->client()->focusNext();
    213 }
    214 
    215 void ChromeClientImpl::focusedNodeChanged(Node* node)
    216 {
    217     m_webView->client()->focusedNodeChanged(WebNode(node));
    218 
    219     WebURL focusURL;
    220     if (node && node->isLink()) {
    221         // This HitTestResult hack is the easiest way to get a link URL out of a
    222         // WebCore::Node.
    223         HitTestResult hitTest(IntPoint(0, 0));
    224         // This cast must be valid because of the isLink() check.
    225         hitTest.setURLElement(toElement(node));
    226         if (hitTest.isLiveLink())
    227             focusURL = hitTest.absoluteLinkURL();
    228     }
    229     m_webView->client()->setKeyboardFocusURL(focusURL);
    230 }
    231 
    232 Page* ChromeClientImpl::createWindow(
    233     Frame* frame, const FrameLoadRequest& r, const WindowFeatures& features, const NavigationAction& action, NavigationPolicy navigationPolicy)
    234 {
    235     if (!m_webView->client())
    236         return 0;
    237 
    238     WebNavigationPolicy policy = static_cast<WebNavigationPolicy>(navigationPolicy);
    239     if (policy == WebNavigationPolicyIgnore)
    240         policy = getNavigationPolicy();
    241 
    242     WrappedResourceRequest request;
    243     if (!r.resourceRequest().isEmpty())
    244         request.bind(r.resourceRequest());
    245     else if (!action.resourceRequest().isEmpty())
    246         request.bind(action.resourceRequest());
    247     WebViewImpl* newView = static_cast<WebViewImpl*>(
    248         m_webView->client()->createView(WebFrameImpl::fromFrame(frame), request, features, r.frameName(), policy));
    249     if (!newView)
    250         return 0;
    251     return newView->page();
    252 }
    253 
    254 static inline void updatePolicyForEvent(const WebInputEvent* inputEvent, NavigationPolicy* policy)
    255 {
    256     if (!inputEvent || inputEvent->type != WebInputEvent::MouseUp)
    257         return;
    258 
    259     const WebMouseEvent* mouseEvent = static_cast<const WebMouseEvent*>(inputEvent);
    260 
    261     unsigned short buttonNumber;
    262     switch (mouseEvent->button) {
    263     case WebMouseEvent::ButtonLeft:
    264         buttonNumber = 0;
    265         break;
    266     case WebMouseEvent::ButtonMiddle:
    267         buttonNumber = 1;
    268         break;
    269     case WebMouseEvent::ButtonRight:
    270         buttonNumber = 2;
    271         break;
    272     default:
    273         return;
    274     }
    275     bool ctrl = mouseEvent->modifiers & WebMouseEvent::ControlKey;
    276     bool shift = mouseEvent->modifiers & WebMouseEvent::ShiftKey;
    277     bool alt = mouseEvent->modifiers & WebMouseEvent::AltKey;
    278     bool meta = mouseEvent->modifiers & WebMouseEvent::MetaKey;
    279 
    280     NavigationPolicy userPolicy = *policy;
    281     navigationPolicyFromMouseEvent(buttonNumber, ctrl, shift, alt, meta, &userPolicy);
    282     // User and app agree that we want a new window; let the app override the decorations.
    283     if (userPolicy == NavigationPolicyNewWindow && *policy == NavigationPolicyNewPopup)
    284         return;
    285     *policy = userPolicy;
    286 }
    287 
    288 WebNavigationPolicy ChromeClientImpl::getNavigationPolicy()
    289 {
    290     // If our default configuration was modified by a script or wasn't
    291     // created by a user gesture, then show as a popup. Else, let this
    292     // new window be opened as a toplevel window.
    293     bool asPopup = !m_toolbarsVisible
    294         || !m_statusbarVisible
    295         || !m_scrollbarsVisible
    296         || !m_menubarVisible
    297         || !m_resizable;
    298 
    299     NavigationPolicy policy = NavigationPolicyNewForegroundTab;
    300     if (asPopup)
    301         policy = NavigationPolicyNewPopup;
    302     updatePolicyForEvent(WebViewImpl::currentInputEvent(), &policy);
    303 
    304     return static_cast<WebNavigationPolicy>(policy);
    305 }
    306 
    307 void ChromeClientImpl::show(NavigationPolicy navigationPolicy)
    308 {
    309     if (!m_webView->client())
    310         return;
    311 
    312     WebNavigationPolicy policy = static_cast<WebNavigationPolicy>(navigationPolicy);
    313     if (policy == WebNavigationPolicyIgnore)
    314         policy = getNavigationPolicy();
    315     m_webView->client()->show(policy);
    316 }
    317 
    318 bool ChromeClientImpl::canRunModal()
    319 {
    320     return !!m_webView->client();
    321 }
    322 
    323 void ChromeClientImpl::runModal()
    324 {
    325     if (m_webView->client())
    326         m_webView->client()->runModal();
    327 }
    328 
    329 void ChromeClientImpl::setToolbarsVisible(bool value)
    330 {
    331     m_toolbarsVisible = value;
    332 }
    333 
    334 bool ChromeClientImpl::toolbarsVisible()
    335 {
    336     return m_toolbarsVisible;
    337 }
    338 
    339 void ChromeClientImpl::setStatusbarVisible(bool value)
    340 {
    341     m_statusbarVisible = value;
    342 }
    343 
    344 bool ChromeClientImpl::statusbarVisible()
    345 {
    346     return m_statusbarVisible;
    347 }
    348 
    349 void ChromeClientImpl::setScrollbarsVisible(bool value)
    350 {
    351     m_scrollbarsVisible = value;
    352     WebFrameImpl* webFrame = static_cast<WebFrameImpl*>(m_webView->mainFrame());
    353     if (webFrame)
    354         webFrame->setCanHaveScrollbars(value);
    355 }
    356 
    357 bool ChromeClientImpl::scrollbarsVisible()
    358 {
    359     return m_scrollbarsVisible;
    360 }
    361 
    362 void ChromeClientImpl::setMenubarVisible(bool value)
    363 {
    364     m_menubarVisible = value;
    365 }
    366 
    367 bool ChromeClientImpl::menubarVisible()
    368 {
    369     return m_menubarVisible;
    370 }
    371 
    372 void ChromeClientImpl::setResizable(bool value)
    373 {
    374     m_resizable = value;
    375 }
    376 
    377 void ChromeClientImpl::addMessageToConsole(MessageSource source,
    378                                            MessageLevel level,
    379                                            const String& message,
    380                                            unsigned lineNumber,
    381                                            const String& sourceID)
    382 {
    383     if (m_webView->client()) {
    384         m_webView->client()->didAddMessageToConsole(
    385             WebConsoleMessage(static_cast<WebConsoleMessage::Level>(level), message),
    386             sourceID,
    387             lineNumber);
    388     }
    389 }
    390 
    391 bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel()
    392 {
    393     return !!m_webView->client();
    394 }
    395 
    396 bool ChromeClientImpl::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)
    397 {
    398     if (m_webView->client()) {
    399         return m_webView->client()->runModalBeforeUnloadDialog(
    400             WebFrameImpl::fromFrame(frame), message);
    401     }
    402     return false;
    403 }
    404 
    405 void ChromeClientImpl::closeWindowSoon()
    406 {
    407     // Make sure this Page can no longer be found by JS.
    408     m_webView->page()->clearPageGroup();
    409 
    410     // Make sure that all loading is stopped.  Ensures that JS stops executing!
    411     m_webView->mainFrame()->stopLoading();
    412 
    413     if (m_webView->client())
    414         m_webView->client()->closeWidgetSoon();
    415 }
    416 
    417 // Although a Frame is passed in, we don't actually use it, since we
    418 // already know our own m_webView.
    419 void ChromeClientImpl::runJavaScriptAlert(Frame* frame, const String& message)
    420 {
    421     if (m_webView->client()) {
    422         if (WebUserGestureIndicator::isProcessingUserGesture())
    423             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
    424         m_webView->client()->runModalAlertDialog(
    425             WebFrameImpl::fromFrame(frame), message);
    426     }
    427 }
    428 
    429 // See comments for runJavaScriptAlert().
    430 bool ChromeClientImpl::runJavaScriptConfirm(Frame* frame, const String& message)
    431 {
    432     if (m_webView->client()) {
    433         if (WebUserGestureIndicator::isProcessingUserGesture())
    434             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
    435         return m_webView->client()->runModalConfirmDialog(
    436             WebFrameImpl::fromFrame(frame), message);
    437     }
    438     return false;
    439 }
    440 
    441 // See comments for runJavaScriptAlert().
    442 bool ChromeClientImpl::runJavaScriptPrompt(Frame* frame,
    443                                            const String& message,
    444                                            const String& defaultValue,
    445                                            String& result)
    446 {
    447     if (m_webView->client()) {
    448         if (WebUserGestureIndicator::isProcessingUserGesture())
    449             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
    450         WebString actualValue;
    451         bool ok = m_webView->client()->runModalPromptDialog(
    452             WebFrameImpl::fromFrame(frame),
    453             message,
    454             defaultValue,
    455             &actualValue);
    456         if (ok)
    457             result = actualValue;
    458         return ok;
    459     }
    460     return false;
    461 }
    462 
    463 void ChromeClientImpl::setStatusbarText(const String& message)
    464 {
    465     if (m_webView->client())
    466         m_webView->client()->setStatusText(message);
    467 }
    468 
    469 bool ChromeClientImpl::tabsToLinks()
    470 {
    471     return m_webView->tabsToLinks();
    472 }
    473 
    474 IntRect ChromeClientImpl::windowResizerRect() const
    475 {
    476     IntRect result;
    477     if (m_webView->client())
    478         result = m_webView->client()->windowResizerRect();
    479     return result;
    480 }
    481 
    482 void ChromeClientImpl::invalidateContentsAndRootView(const IntRect& updateRect)
    483 {
    484     if (updateRect.isEmpty())
    485         return;
    486     m_webView->invalidateRect(updateRect);
    487 }
    488 
    489 void ChromeClientImpl::invalidateContentsForSlowScroll(const IntRect& updateRect)
    490 {
    491     invalidateContentsAndRootView(updateRect);
    492 }
    493 
    494 void ChromeClientImpl::scheduleAnimation()
    495 {
    496     m_webView->scheduleAnimation();
    497 }
    498 
    499 void ChromeClientImpl::scroll(
    500     const IntSize& scrollDelta, const IntRect& scrollRect,
    501     const IntRect& clipRect)
    502 {
    503     if (!m_webView->isAcceleratedCompositingActive()) {
    504         if (m_webView->client()) {
    505             int dx = scrollDelta.width();
    506             int dy = scrollDelta.height();
    507             m_webView->client()->didScrollRect(dx, dy, intersection(scrollRect, clipRect));
    508         }
    509     } else
    510         m_webView->scrollRootLayerRect(scrollDelta, clipRect);
    511 }
    512 
    513 IntPoint ChromeClientImpl::screenToRootView(const IntPoint& point) const
    514 {
    515     IntPoint windowPoint(point);
    516 
    517     if (m_webView->client()) {
    518         WebRect windowRect = m_webView->client()->windowRect();
    519         windowPoint.move(-windowRect.x, -windowRect.y);
    520     }
    521 
    522     return windowPoint;
    523 }
    524 
    525 IntRect ChromeClientImpl::rootViewToScreen(const IntRect& rect) const
    526 {
    527     IntRect screenRect(rect);
    528 
    529     if (m_webView->client()) {
    530         WebRect windowRect = m_webView->client()->windowRect();
    531         screenRect.move(windowRect.x, windowRect.y);
    532     }
    533 
    534     return screenRect;
    535 }
    536 
    537 WebScreenInfo ChromeClientImpl::screenInfo() const
    538 {
    539     return m_webView->client() ? m_webView->client()->screenInfo() : WebScreenInfo();
    540 }
    541 
    542 void ChromeClientImpl::contentsSizeChanged(Frame* frame, const IntSize& size) const
    543 {
    544     m_webView->didChangeContentsSize();
    545 
    546     WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
    547     webframe->didChangeContentsSize(size);
    548     if (webframe->client())
    549         webframe->client()->didChangeContentsSize(webframe, size);
    550 }
    551 
    552 void ChromeClientImpl::deviceOrPageScaleFactorChanged() const
    553 {
    554     m_webView->deviceOrPageScaleFactorChanged();
    555 }
    556 
    557 void ChromeClientImpl::didProgrammaticallyScroll(Frame* frame, const IntPoint& scrollPoint) const
    558 {
    559     ASSERT(frame->view()->inProgrammaticScroll());
    560     if (frame->page()->mainFrame() == frame)
    561         m_webView->didProgrammaticallyScroll(scrollPoint);
    562 }
    563 
    564 void ChromeClientImpl::layoutUpdated(Frame* frame) const
    565 {
    566     m_webView->layoutUpdated(WebFrameImpl::fromFrame(frame));
    567 }
    568 
    569 void ChromeClientImpl::mouseDidMoveOverElement(
    570     const HitTestResult& result, unsigned modifierFlags)
    571 {
    572     if (!m_webView->client())
    573         return;
    574 
    575     WebURL url;
    576     // Find out if the mouse is over a link, and if so, let our UI know...
    577     if (result.isLiveLink() && !result.absoluteLinkURL().string().isEmpty())
    578         url = result.absoluteLinkURL();
    579     else if (result.innerNonSharedNode()
    580              && (result.innerNonSharedNode()->hasTagName(HTMLNames::objectTag)
    581                  || result.innerNonSharedNode()->hasTagName(HTMLNames::embedTag))) {
    582         RenderObject* object = result.innerNonSharedNode()->renderer();
    583         if (object && object->isWidget()) {
    584             Widget* widget = toRenderWidget(object)->widget();
    585             if (widget && widget->isPluginContainer()) {
    586                 WebPluginContainerImpl* plugin = static_cast<WebPluginContainerImpl*>(widget);
    587                 url = plugin->plugin()->linkAtPosition(result.roundedPointInInnerNodeFrame());
    588             }
    589         }
    590     }
    591 
    592     m_webView->client()->setMouseOverURL(url);
    593 }
    594 
    595 void ChromeClientImpl::setToolTip(const String& tooltipText, TextDirection dir)
    596 {
    597     if (!m_webView->client())
    598         return;
    599     WebTextDirection textDirection = (dir == RTL) ?
    600         WebTextDirectionRightToLeft :
    601         WebTextDirectionLeftToRight;
    602     m_webView->client()->setToolTipText(
    603         tooltipText, textDirection);
    604 }
    605 
    606 void ChromeClientImpl::dispatchViewportPropertiesDidChange(const ViewportArguments& arguments) const
    607 {
    608     m_webView->updatePageDefinedPageScaleConstraints(arguments);
    609 }
    610 
    611 void ChromeClientImpl::print(Frame* frame)
    612 {
    613     if (m_webView->client())
    614         m_webView->client()->printPage(WebFrameImpl::fromFrame(frame));
    615 }
    616 
    617 PassOwnPtr<ColorChooser> ChromeClientImpl::createColorChooser(ColorChooserClient* chooserClient, const Color&)
    618 {
    619     OwnPtr<ColorChooserUIController> controller;
    620     if (RuntimeEnabledFeatures::pagePopupEnabled())
    621         controller = adoptPtr(new ColorChooserPopupUIController(this, chooserClient));
    622     else
    623         controller = adoptPtr(new ColorChooserUIController(this, chooserClient));
    624     controller->openUI();
    625     return controller.release();
    626 }
    627 PassOwnPtr<WebColorChooser> ChromeClientImpl::createWebColorChooser(WebColorChooserClient* chooserClient, const WebColor& initialColor)
    628 {
    629     WebViewClient* client = m_webView->client();
    630     if (!client)
    631         return nullptr;
    632     return adoptPtr(client->createColorChooser(chooserClient, initialColor));
    633 }
    634 
    635 PassRefPtr<DateTimeChooser> ChromeClientImpl::openDateTimeChooser(DateTimeChooserClient* pickerClient, const DateTimeChooserParameters& parameters)
    636 {
    637 #if ENABLE(INPUT_MULTIPLE_FIELDS_UI)
    638     return DateTimeChooserImpl::create(this, pickerClient, parameters);
    639 #else
    640     return ExternalDateTimeChooser::create(this, m_webView->client(), pickerClient, parameters);
    641 #endif
    642 }
    643 
    644 void ChromeClientImpl::runOpenPanel(Frame* frame, PassRefPtr<FileChooser> fileChooser)
    645 {
    646     WebViewClient* client = m_webView->client();
    647     if (!client)
    648         return;
    649 
    650     WebFileChooserParams params;
    651     params.multiSelect = fileChooser->settings().allowsMultipleFiles;
    652     params.directory = fileChooser->settings().allowsDirectoryUpload;
    653     params.acceptTypes = fileChooser->settings().acceptTypes();
    654     params.selectedFiles = fileChooser->settings().selectedFiles;
    655     if (params.selectedFiles.size() > 0)
    656         params.initialValue = params.selectedFiles[0];
    657 #if ENABLE(MEDIA_CAPTURE)
    658     params.useMediaCapture = fileChooser->settings().useMediaCapture;
    659 #endif
    660     WebFileChooserCompletionImpl* chooserCompletion =
    661         new WebFileChooserCompletionImpl(fileChooser);
    662 
    663     if (client->runFileChooser(params, chooserCompletion))
    664         return;
    665 
    666     // Choosing failed, so do callback with an empty list.
    667     chooserCompletion->didChooseFile(WebVector<WebString>());
    668 }
    669 
    670 void ChromeClientImpl::enumerateChosenDirectory(FileChooser* fileChooser)
    671 {
    672     WebViewClient* client = m_webView->client();
    673     if (!client)
    674         return;
    675 
    676     WebFileChooserCompletionImpl* chooserCompletion =
    677         new WebFileChooserCompletionImpl(fileChooser);
    678 
    679     ASSERT(fileChooser && fileChooser->settings().selectedFiles.size());
    680 
    681     // If the enumeration can't happen, call the callback with an empty list.
    682     if (!client->enumerateChosenDirectory(fileChooser->settings().selectedFiles[0], chooserCompletion))
    683         chooserCompletion->didChooseFile(WebVector<WebString>());
    684 }
    685 
    686 void ChromeClientImpl::popupOpened(PopupContainer* popupContainer,
    687                                    const IntRect& bounds,
    688                                    bool handleExternally)
    689 {
    690     // For Autofill popups, if the popup will not be fully visible, we shouldn't
    691     // show it at all. Among other things, this prevents users from being able
    692     // to interact via the keyboard with an invisible popup.
    693     if (popupContainer->popupType() == PopupContainer::Suggestion) {
    694         FrameView* view = m_webView->page()->mainFrame()->view();
    695         IntRect visibleRect = view->visibleContentRect(ScrollableArea::IncludeScrollbars);
    696         // |bounds| is in screen coordinates, so make sure to convert it to
    697         // content coordinates prior to comparing to |visibleRect|.
    698         IntRect screenRect = bounds;
    699         screenRect.setLocation(view->screenToContents(bounds.location()));
    700         if (!visibleRect.contains(screenRect)) {
    701             m_webView->hideAutofillPopup();
    702             return;
    703         }
    704     }
    705 
    706     if (!m_webView->client())
    707         return;
    708 
    709     WebWidget* webwidget;
    710     if (handleExternally) {
    711         WebPopupMenuInfo popupInfo;
    712         getPopupMenuInfo(popupContainer, &popupInfo);
    713         webwidget = m_webView->client()->createPopupMenu(popupInfo);
    714     } else {
    715         webwidget = m_webView->client()->createPopupMenu(
    716             convertPopupType(popupContainer->popupType()));
    717         // We only notify when the WebView has to handle the popup, as when
    718         // the popup is handled externally, the fact that a popup is showing is
    719         // transparent to the WebView.
    720         m_webView->popupOpened(popupContainer);
    721     }
    722     static_cast<WebPopupMenuImpl*>(webwidget)->initialize(popupContainer, bounds);
    723 }
    724 
    725 void ChromeClientImpl::popupClosed(WebCore::PopupContainer* popupContainer)
    726 {
    727     m_webView->popupClosed(popupContainer);
    728 }
    729 
    730 void ChromeClientImpl::setCursor(const WebCore::Cursor& cursor)
    731 {
    732     setCursor(WebCursorInfo(cursor));
    733 }
    734 
    735 void ChromeClientImpl::setCursor(const WebCursorInfo& cursor)
    736 {
    737 #if OS(DARWIN)
    738     // On Mac the mousemove event propagates to both the popup and main window.
    739     // If a popup is open we don't want the main window to change the cursor.
    740     if (m_webView->hasOpenedPopup())
    741         return;
    742 #endif
    743     if (m_webView->client())
    744         m_webView->client()->didChangeCursor(cursor);
    745 }
    746 
    747 void ChromeClientImpl::setCursorForPlugin(const WebCursorInfo& cursor)
    748 {
    749     setCursor(cursor);
    750 }
    751 
    752 void ChromeClientImpl::formStateDidChange(const Node* node)
    753 {
    754     if (m_webView->client())
    755         m_webView->client()->didChangeFormState(WebNode(const_cast<Node*>(node)));
    756 
    757     // The current history item is not updated yet.  That happens lazily when
    758     // WebFrame::currentHistoryItem is requested.
    759     WebFrameImpl* webframe = WebFrameImpl::fromFrame(node->document()->frame());
    760     if (webframe->client())
    761         webframe->client()->didUpdateCurrentHistoryItem(webframe);
    762 }
    763 
    764 void ChromeClientImpl::getPopupMenuInfo(PopupContainer* popupContainer,
    765                                         WebPopupMenuInfo* info)
    766 {
    767     const Vector<PopupItem*>& inputItems = popupContainer->popupData();
    768 
    769     WebVector<WebMenuItemInfo> outputItems(inputItems.size());
    770 
    771     for (size_t i = 0; i < inputItems.size(); ++i) {
    772         const PopupItem& inputItem = *inputItems[i];
    773         WebMenuItemInfo& outputItem = outputItems[i];
    774 
    775         outputItem.label = inputItem.label;
    776         outputItem.enabled = inputItem.enabled;
    777         if (inputItem.textDirection == WebCore::RTL)
    778             outputItem.textDirection = WebTextDirectionRightToLeft;
    779         else
    780             outputItem.textDirection = WebTextDirectionLeftToRight;
    781         outputItem.hasTextDirectionOverride = inputItem.hasTextDirectionOverride;
    782 
    783         switch (inputItem.type) {
    784         case PopupItem::TypeOption:
    785             outputItem.type = WebMenuItemInfo::Option;
    786             break;
    787         case PopupItem::TypeGroup:
    788             outputItem.type = WebMenuItemInfo::Group;
    789             break;
    790         case PopupItem::TypeSeparator:
    791             outputItem.type = WebMenuItemInfo::Separator;
    792             break;
    793         default:
    794             ASSERT_NOT_REACHED();
    795         }
    796     }
    797 
    798     info->itemHeight = popupContainer->menuItemHeight();
    799     info->itemFontSize = popupContainer->menuItemFontSize();
    800     info->selectedIndex = popupContainer->selectedIndex();
    801     info->items.swap(outputItems);
    802     info->rightAligned = popupContainer->menuStyle().textDirection() == RTL;
    803 }
    804 
    805 void ChromeClientImpl::postAccessibilityNotification(AccessibilityObject* obj, AXObjectCache::AXNotification notification)
    806 {
    807     // Alert assistive technology about the accessibility object notification.
    808     if (obj)
    809         m_webView->client()->postAccessibilityNotification(WebAccessibilityObject(obj), toWebAccessibilityNotification(notification));
    810 }
    811 
    812 String ChromeClientImpl::acceptLanguages()
    813 {
    814     return m_webView->client()->acceptLanguages();
    815 }
    816 
    817 bool ChromeClientImpl::paintCustomOverhangArea(GraphicsContext* context, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect)
    818 {
    819     Frame* frame = m_webView->mainFrameImpl()->frame();
    820     WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame);
    821     if (pluginContainer)
    822         return pluginContainer->paintCustomOverhangArea(context, horizontalOverhangArea, verticalOverhangArea, dirtyRect);
    823     return false;
    824 }
    825 
    826 GraphicsLayerFactory* ChromeClientImpl::graphicsLayerFactory() const
    827 {
    828     return m_webView->graphicsLayerFactory();
    829 }
    830 
    831 void ChromeClientImpl::attachRootGraphicsLayer(Frame* frame, GraphicsLayer* graphicsLayer)
    832 {
    833     m_webView->setRootGraphicsLayer(graphicsLayer);
    834 }
    835 
    836 void ChromeClientImpl::scheduleCompositingLayerFlush()
    837 {
    838     m_webView->scheduleCompositingLayerSync();
    839 }
    840 
    841 ChromeClient::CompositingTriggerFlags ChromeClientImpl::allowedCompositingTriggers() const
    842 {
    843     if (!m_webView->allowsAcceleratedCompositing())
    844         return 0;
    845 
    846     CompositingTriggerFlags flags = 0;
    847     Settings* settings = m_webView->page()->settings();
    848     if (settings->acceleratedCompositingFor3DTransformsEnabled())
    849         flags |= ThreeDTransformTrigger;
    850     if (settings->acceleratedCompositingForVideoEnabled())
    851         flags |= VideoTrigger;
    852     if (settings->acceleratedCompositingForPluginsEnabled())
    853         flags |= PluginTrigger;
    854     if (settings->acceleratedCompositingForAnimationEnabled())
    855         flags |= AnimationTrigger;
    856     if (settings->acceleratedCompositingForCanvasEnabled())
    857         flags |= CanvasTrigger;
    858     if (settings->acceleratedCompositingForScrollableFramesEnabled())
    859         flags |= ScrollableInnerFrameTrigger;
    860     if (settings->acceleratedCompositingForFiltersEnabled())
    861         flags |= FilterTrigger;
    862 
    863     return flags;
    864 }
    865 
    866 void ChromeClientImpl::enterFullScreenForElement(Element* element)
    867 {
    868     m_webView->enterFullScreenForElement(element);
    869 }
    870 
    871 void ChromeClientImpl::exitFullScreenForElement(Element* element)
    872 {
    873     m_webView->exitFullScreenForElement(element);
    874 }
    875 
    876 bool ChromeClientImpl::hasOpenedPopup() const
    877 {
    878     return m_webView->hasOpenedPopup();
    879 }
    880 
    881 PassRefPtr<PopupMenu> ChromeClientImpl::createPopupMenu(Frame& frame, PopupMenuClient* client) const
    882 {
    883     if (WebViewImpl::useExternalPopupMenus())
    884         return adoptRef(new ExternalPopupMenu(frame, client, m_webView->client()));
    885 
    886     return adoptRef(new PopupMenuChromium(frame, client));
    887 }
    888 
    889 PagePopup* ChromeClientImpl::openPagePopup(PagePopupClient* client, const IntRect& originBoundsInRootView)
    890 {
    891     ASSERT(m_pagePopupDriver);
    892     return m_pagePopupDriver->openPagePopup(client, originBoundsInRootView);
    893 }
    894 
    895 void ChromeClientImpl::closePagePopup(PagePopup* popup)
    896 {
    897     ASSERT(m_pagePopupDriver);
    898     m_pagePopupDriver->closePagePopup(popup);
    899 }
    900 
    901 void ChromeClientImpl::setPagePopupDriver(PagePopupDriver* driver)
    902 {
    903     ASSERT(driver);
    904     m_pagePopupDriver = driver;
    905 }
    906 
    907 void ChromeClientImpl::resetPagePopupDriver()
    908 {
    909     m_pagePopupDriver = m_webView;
    910 }
    911 
    912 bool ChromeClientImpl::isPasswordGenerationEnabled() const
    913 {
    914     return m_webView->passwordGeneratorClient();
    915 }
    916 
    917 void ChromeClientImpl::openPasswordGenerator(HTMLInputElement* input)
    918 {
    919     ASSERT(isPasswordGenerationEnabled());
    920     WebInputElement webInput(input);
    921     m_webView->passwordGeneratorClient()->openPasswordGenerator(webInput);
    922 }
    923 
    924 bool ChromeClientImpl::shouldRunModalDialogDuringPageDismissal(const DialogType& dialogType, const String& dialogMessage, FrameLoader::PageDismissalType dismissalType) const
    925 {
    926     const char* kDialogs[] = {"alert", "confirm", "prompt", "showModalDialog"};
    927     int dialog = static_cast<int>(dialogType);
    928     ASSERT_WITH_SECURITY_IMPLICATION(0 <= dialog && dialog < static_cast<int>(arraysize(kDialogs)));
    929 
    930     const char* kDismissals[] = {"beforeunload", "pagehide", "unload"};
    931     int dismissal = static_cast<int>(dismissalType) - 1; // Exclude NoDismissal.
    932     ASSERT_WITH_SECURITY_IMPLICATION(0 <= dismissal && dismissal < static_cast<int>(arraysize(kDismissals)));
    933 
    934     WebKit::Platform::current()->histogramEnumeration("Renderer.ModalDialogsDuringPageDismissal", dismissal * arraysize(kDialogs) + dialog, arraysize(kDialogs) * arraysize(kDismissals));
    935 
    936     String message = String("Blocked ") + kDialogs[dialog] + "('" + dialogMessage + "') during " + kDismissals[dismissal] + ".";
    937     m_webView->mainFrame()->addMessageToConsole(WebConsoleMessage(WebConsoleMessage::LevelError, message));
    938 
    939     return false;
    940 }
    941 
    942 bool ChromeClientImpl::shouldRubberBandInDirection(WebCore::ScrollDirection direction) const
    943 {
    944     ASSERT(direction != WebCore::ScrollUp && direction != WebCore::ScrollDown);
    945 
    946     if (!m_webView->client())
    947         return false;
    948 
    949     if (direction == WebCore::ScrollLeft)
    950         return !m_webView->client()->historyBackListCount();
    951     if (direction == WebCore::ScrollRight)
    952         return !m_webView->client()->historyForwardListCount();
    953 
    954     ASSERT_NOT_REACHED();
    955     return true;
    956 }
    957 
    958 void ChromeClientImpl::numWheelEventHandlersChanged(unsigned numberOfWheelHandlers)
    959 {
    960     m_webView->numberOfWheelEventHandlersChanged(numberOfWheelHandlers);
    961 }
    962 
    963 void ChromeClientImpl::needTouchEvents(bool needsTouchEvents)
    964 {
    965     m_webView->hasTouchEventHandlers(needsTouchEvents);
    966 }
    967 
    968 bool ChromeClientImpl::requestPointerLock()
    969 {
    970     return m_webView->requestPointerLock();
    971 }
    972 
    973 void ChromeClientImpl::requestPointerUnlock()
    974 {
    975     return m_webView->requestPointerUnlock();
    976 }
    977 
    978 bool ChromeClientImpl::isPointerLocked()
    979 {
    980     return m_webView->isPointerLocked();
    981 }
    982 
    983 void ChromeClientImpl::annotatedRegionsChanged()
    984 {
    985     WebViewClient* client = m_webView->client();
    986     if (client)
    987         client->draggableRegionsChanged();
    988 }
    989 
    990 void ChromeClientImpl::didAssociateFormControls(const Vector<RefPtr<Element> >& elements)
    991 {
    992     if (!m_webView->autofillClient())
    993         return;
    994     WebVector<WebNode> elementVector(static_cast<size_t>(elements.size()));
    995     size_t elementsCount = elements.size();
    996     for (size_t i = 0; i < elementsCount; ++i)
    997         elementVector[i] = elements[i];
    998     m_webView->autofillClient()->didAssociateFormControls(elementVector);
    999 }
   1000 
   1001 #if ENABLE(NAVIGATOR_CONTENT_UTILS)
   1002 PassOwnPtr<NavigatorContentUtilsClientImpl> NavigatorContentUtilsClientImpl::create(WebViewImpl* webView)
   1003 {
   1004     return adoptPtr(new NavigatorContentUtilsClientImpl(webView));
   1005 }
   1006 
   1007 NavigatorContentUtilsClientImpl::NavigatorContentUtilsClientImpl(WebViewImpl* webView)
   1008     : m_webView(webView)
   1009 {
   1010 }
   1011 
   1012 void NavigatorContentUtilsClientImpl::registerProtocolHandler(const String& scheme, const String& baseURL, const String& url, const String& title)
   1013 {
   1014     m_webView->client()->registerProtocolHandler(scheme, baseURL, url, title);
   1015 }
   1016 #endif
   1017 
   1018 } // namespace WebKit
   1019