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 "web/ChromeClientImpl.h"
34
35#include "bindings/core/v8/ScriptController.h"
36#include "core/HTMLNames.h"
37#include "core/accessibility/AXObject.h"
38#include "core/accessibility/AXObjectCache.h"
39#include "core/dom/Document.h"
40#include "core/dom/Fullscreen.h"
41#include "core/dom/Node.h"
42#include "core/events/KeyboardEvent.h"
43#include "core/events/MouseEvent.h"
44#include "core/events/WheelEvent.h"
45#include "core/frame/Console.h"
46#include "core/frame/FrameView.h"
47#include "core/frame/Settings.h"
48#include "core/html/HTMLInputElement.h"
49#include "core/html/forms/ColorChooser.h"
50#include "core/html/forms/ColorChooserClient.h"
51#include "core/html/forms/DateTimeChooser.h"
52#include "core/loader/DocumentLoader.h"
53#include "core/loader/FrameLoadRequest.h"
54#include "core/page/Page.h"
55#include "core/page/PagePopupDriver.h"
56#include "core/page/WindowFeatures.h"
57#include "core/rendering/HitTestResult.h"
58#include "core/rendering/RenderPart.h"
59#include "core/rendering/RenderWidget.h"
60#include "core/rendering/compositing/CompositedSelectionBound.h"
61#include "platform/Cursor.h"
62#include "platform/FileChooser.h"
63#include "platform/NotImplemented.h"
64#include "platform/PlatformScreen.h"
65#include "platform/RuntimeEnabledFeatures.h"
66#include "platform/exported/WrappedResourceRequest.h"
67#include "platform/geometry/FloatRect.h"
68#include "platform/geometry/IntRect.h"
69#include "platform/graphics/GraphicsLayer.h"
70#include "platform/weborigin/SecurityOrigin.h"
71#include "public/platform/Platform.h"
72#include "public/platform/WebCursorInfo.h"
73#include "public/platform/WebRect.h"
74#include "public/platform/WebSelectionBound.h"
75#include "public/platform/WebURLRequest.h"
76#include "public/web/WebAXObject.h"
77#include "public/web/WebAutofillClient.h"
78#include "public/web/WebColorChooser.h"
79#include "public/web/WebColorSuggestion.h"
80#include "public/web/WebConsoleMessage.h"
81#include "public/web/WebFrameClient.h"
82#include "public/web/WebInputElement.h"
83#include "public/web/WebInputEvent.h"
84#include "public/web/WebKit.h"
85#include "public/web/WebNode.h"
86#include "public/web/WebPlugin.h"
87#include "public/web/WebPopupMenuInfo.h"
88#include "public/web/WebSettings.h"
89#include "public/web/WebTextDirection.h"
90#include "public/web/WebTouchAction.h"
91#include "public/web/WebUserGestureIndicator.h"
92#include "public/web/WebUserGestureToken.h"
93#include "public/web/WebViewClient.h"
94#include "public/web/WebWindowFeatures.h"
95#include "web/ColorChooserPopupUIController.h"
96#include "web/ColorChooserUIController.h"
97#include "web/DateTimeChooserImpl.h"
98#include "web/ExternalDateTimeChooser.h"
99#include "web/ExternalPopupMenu.h"
100#include "web/PopupMenuChromium.h"
101#include "web/WebFileChooserCompletionImpl.h"
102#include "web/WebInputEventConversion.h"
103#include "web/WebLocalFrameImpl.h"
104#include "web/WebPluginContainerImpl.h"
105#include "web/WebPopupMenuImpl.h"
106#include "web/WebSettingsImpl.h"
107#include "web/WebViewImpl.h"
108#include "wtf/text/CString.h"
109#include "wtf/text/StringBuilder.h"
110#include "wtf/text/StringConcatenate.h"
111#include "wtf/unicode/CharacterNames.h"
112
113namespace blink {
114
115// Converts a AXObjectCache::AXNotification to a WebAXEvent
116static WebAXEvent toWebAXEvent(AXObjectCache::AXNotification notification)
117{
118    // These enums have the same values; enforced in AssertMatchingEnums.cpp.
119    return static_cast<WebAXEvent>(notification);
120}
121
122static WebSelectionBound toWebSelectionBound(const CompositedSelectionBound& bound)
123{
124    ASSERT(bound.layer);
125
126    // These enums have the same values; enforced in AssertMatchingEnums.cpp.
127    WebSelectionBound result(static_cast<WebSelectionBound::Type>(bound.type));
128    result.layerId = bound.layer->platformLayer()->id();
129    result.edgeTopInLayer = roundedIntPoint(bound.edgeTopInLayer);
130    result.edgeBottomInLayer = roundedIntPoint(bound.edgeBottomInLayer);
131    return result;
132}
133
134ChromeClientImpl::ChromeClientImpl(WebViewImpl* webView)
135    : m_webView(webView)
136    , m_toolbarsVisible(true)
137    , m_statusbarVisible(true)
138    , m_scrollbarsVisible(true)
139    , m_menubarVisible(true)
140    , m_resizable(true)
141    , m_pagePopupDriver(webView)
142{
143}
144
145ChromeClientImpl::~ChromeClientImpl()
146{
147}
148
149void* ChromeClientImpl::webView() const
150{
151    return static_cast<void*>(m_webView);
152}
153
154void ChromeClientImpl::chromeDestroyed()
155{
156    // Our lifetime is bound to the WebViewImpl.
157}
158
159void ChromeClientImpl::setWindowRect(const FloatRect& r)
160{
161    if (m_webView->client())
162        m_webView->client()->setWindowRect(IntRect(r));
163}
164
165FloatRect ChromeClientImpl::windowRect()
166{
167    WebRect rect;
168    if (m_webView->client())
169        rect = m_webView->client()->rootWindowRect();
170    else {
171        // These numbers will be fairly wrong. The window's x/y coordinates will
172        // be the top left corner of the screen and the size will be the content
173        // size instead of the window size.
174        rect.width = m_webView->size().width;
175        rect.height = m_webView->size().height;
176    }
177    return FloatRect(rect);
178}
179
180FloatRect ChromeClientImpl::pageRect()
181{
182    // We hide the details of the window's border thickness from the web page by
183    // simple re-using the window position here.  So, from the point-of-view of
184    // the web page, the window has no border.
185    return windowRect();
186}
187
188void ChromeClientImpl::focus()
189{
190    if (m_webView->client())
191        m_webView->client()->didFocus();
192}
193
194bool ChromeClientImpl::canTakeFocus(FocusType)
195{
196    // For now the browser can always take focus if we're not running layout
197    // tests.
198    return !layoutTestMode();
199}
200
201void ChromeClientImpl::takeFocus(FocusType type)
202{
203    if (!m_webView->client())
204        return;
205    if (type == FocusTypeBackward)
206        m_webView->client()->focusPrevious();
207    else
208        m_webView->client()->focusNext();
209}
210
211void ChromeClientImpl::focusedNodeChanged(Node* node)
212{
213    m_webView->client()->focusedNodeChanged(WebNode(node));
214
215    WebURL focusURL;
216    if (node && node->isElementNode() && toElement(node)->isLiveLink())
217        focusURL = toElement(node)->hrefURL();
218    m_webView->client()->setKeyboardFocusURL(focusURL);
219}
220
221void ChromeClientImpl::focusedFrameChanged(LocalFrame* frame)
222{
223    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
224    if (webframe && webframe->client())
225        webframe->client()->frameFocused();
226}
227
228Page* ChromeClientImpl::createWindow(LocalFrame* frame, const FrameLoadRequest& r, const WindowFeatures& features,
229    NavigationPolicy navigationPolicy, ShouldSendReferrer shouldSendReferrer)
230{
231    if (!m_webView->client())
232        return 0;
233
234    WebNavigationPolicy policy = static_cast<WebNavigationPolicy>(navigationPolicy);
235    if (policy == WebNavigationPolicyIgnore)
236        policy = getNavigationPolicy();
237
238    ASSERT(frame->document());
239    Fullscreen::fullyExitFullscreen(*frame->document());
240
241    WebViewImpl* newView = toWebViewImpl(
242        m_webView->client()->createView(WebLocalFrameImpl::fromFrame(frame), WrappedResourceRequest(r.resourceRequest()), features, r.frameName(), policy, shouldSendReferrer == NeverSendReferrer));
243    if (!newView)
244        return 0;
245    return newView->page();
246}
247
248static inline void updatePolicyForEvent(const WebInputEvent* inputEvent, NavigationPolicy* policy)
249{
250    if (!inputEvent || inputEvent->type != WebInputEvent::MouseUp)
251        return;
252
253    const WebMouseEvent* mouseEvent = static_cast<const WebMouseEvent*>(inputEvent);
254
255    unsigned short buttonNumber;
256    switch (mouseEvent->button) {
257    case WebMouseEvent::ButtonLeft:
258        buttonNumber = 0;
259        break;
260    case WebMouseEvent::ButtonMiddle:
261        buttonNumber = 1;
262        break;
263    case WebMouseEvent::ButtonRight:
264        buttonNumber = 2;
265        break;
266    default:
267        return;
268    }
269    bool ctrl = mouseEvent->modifiers & WebMouseEvent::ControlKey;
270    bool shift = mouseEvent->modifiers & WebMouseEvent::ShiftKey;
271    bool alt = mouseEvent->modifiers & WebMouseEvent::AltKey;
272    bool meta = mouseEvent->modifiers & WebMouseEvent::MetaKey;
273
274    NavigationPolicy userPolicy = *policy;
275    navigationPolicyFromMouseEvent(buttonNumber, ctrl, shift, alt, meta, &userPolicy);
276    // User and app agree that we want a new window; let the app override the decorations.
277    if (userPolicy == NavigationPolicyNewWindow && *policy == NavigationPolicyNewPopup)
278        return;
279    *policy = userPolicy;
280}
281
282WebNavigationPolicy ChromeClientImpl::getNavigationPolicy()
283{
284    // If our default configuration was modified by a script or wasn't
285    // created by a user gesture, then show as a popup. Else, let this
286    // new window be opened as a toplevel window.
287    bool asPopup = !m_toolbarsVisible
288        || !m_statusbarVisible
289        || !m_scrollbarsVisible
290        || !m_menubarVisible
291        || !m_resizable;
292
293    NavigationPolicy policy = NavigationPolicyNewForegroundTab;
294    if (asPopup)
295        policy = NavigationPolicyNewPopup;
296    updatePolicyForEvent(WebViewImpl::currentInputEvent(), &policy);
297
298    return static_cast<WebNavigationPolicy>(policy);
299}
300
301void ChromeClientImpl::show(NavigationPolicy navigationPolicy)
302{
303    if (!m_webView->client())
304        return;
305
306    WebNavigationPolicy policy = static_cast<WebNavigationPolicy>(navigationPolicy);
307    if (policy == WebNavigationPolicyIgnore)
308        policy = getNavigationPolicy();
309    m_webView->client()->show(policy);
310}
311
312bool ChromeClientImpl::canRunModal()
313{
314    return !!m_webView->client();
315}
316
317void ChromeClientImpl::runModal()
318{
319    if (m_webView->client())
320        m_webView->client()->runModal();
321}
322
323void ChromeClientImpl::setToolbarsVisible(bool value)
324{
325    m_toolbarsVisible = value;
326}
327
328bool ChromeClientImpl::toolbarsVisible()
329{
330    return m_toolbarsVisible;
331}
332
333void ChromeClientImpl::setStatusbarVisible(bool value)
334{
335    m_statusbarVisible = value;
336}
337
338bool ChromeClientImpl::statusbarVisible()
339{
340    return m_statusbarVisible;
341}
342
343void ChromeClientImpl::setScrollbarsVisible(bool value)
344{
345    m_scrollbarsVisible = value;
346    WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame());
347    if (webFrame)
348        webFrame->setCanHaveScrollbars(value);
349}
350
351bool ChromeClientImpl::scrollbarsVisible()
352{
353    return m_scrollbarsVisible;
354}
355
356void ChromeClientImpl::setMenubarVisible(bool value)
357{
358    m_menubarVisible = value;
359}
360
361bool ChromeClientImpl::menubarVisible()
362{
363    return m_menubarVisible;
364}
365
366void ChromeClientImpl::setResizable(bool value)
367{
368    m_resizable = value;
369}
370
371bool ChromeClientImpl::shouldReportDetailedMessageForSource(const String& url)
372{
373    WebLocalFrameImpl* webframe = m_webView->localFrameRootTemporary();
374    return webframe->client() && webframe->client()->shouldReportDetailedMessageForSource(url);
375}
376
377void ChromeClientImpl::addMessageToConsole(LocalFrame* localFrame, MessageSource source, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceID, const String& stackTrace)
378{
379    WebLocalFrameImpl* frame = WebLocalFrameImpl::fromFrame(localFrame);
380    if (frame && frame->client()) {
381        frame->client()->didAddMessageToConsole(
382            WebConsoleMessage(static_cast<WebConsoleMessage::Level>(level), message),
383            sourceID,
384            lineNumber,
385            stackTrace);
386    }
387}
388
389bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel()
390{
391    return !!m_webView->client();
392}
393
394bool ChromeClientImpl::runBeforeUnloadConfirmPanel(const String& message, LocalFrame* frame)
395{
396    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
397
398    bool isReload = false;
399    WebDataSource* ds = webframe->provisionalDataSource();
400    if (ds)
401        isReload = (ds->navigationType() == WebNavigationTypeReload);
402
403    if (webframe->client())
404        return webframe->client()->runModalBeforeUnloadDialog(isReload, message);
405    return false;
406}
407
408void ChromeClientImpl::closeWindowSoon()
409{
410    // Make sure this Page can no longer be found by JS.
411    Page::ordinaryPages().remove(m_webView->page());
412
413    // Make sure that all loading is stopped.  Ensures that JS stops executing!
414    m_webView->mainFrame()->stopLoading();
415
416    if (m_webView->client())
417        m_webView->client()->closeWidgetSoon();
418}
419
420// Although a LocalFrame is passed in, we don't actually use it, since we
421// already know our own m_webView.
422void ChromeClientImpl::runJavaScriptAlert(LocalFrame* frame, const String& message)
423{
424    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
425    if (webframe->client()) {
426        if (WebUserGestureIndicator::isProcessingUserGesture())
427            WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
428        webframe->client()->runModalAlertDialog(message);
429    }
430}
431
432// See comments for runJavaScriptAlert().
433bool ChromeClientImpl::runJavaScriptConfirm(LocalFrame* frame, const String& message)
434{
435    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
436    if (webframe->client()) {
437        if (WebUserGestureIndicator::isProcessingUserGesture())
438            WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
439        return webframe->client()->runModalConfirmDialog(message);
440    }
441    return false;
442}
443
444// See comments for runJavaScriptAlert().
445bool ChromeClientImpl::runJavaScriptPrompt(LocalFrame* frame,
446                                           const String& message,
447                                           const String& defaultValue,
448                                           String& result)
449{
450    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
451    if (webframe->client()) {
452        if (WebUserGestureIndicator::isProcessingUserGesture())
453            WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
454        WebString actualValue;
455        bool ok = webframe->client()->runModalPromptDialog(
456            message,
457            defaultValue,
458            &actualValue);
459        if (ok)
460            result = actualValue;
461        return ok;
462    }
463    return false;
464}
465
466void ChromeClientImpl::setStatusbarText(const String& message)
467{
468    if (m_webView->client())
469        m_webView->client()->setStatusText(message);
470}
471
472bool ChromeClientImpl::tabsToLinks()
473{
474    return m_webView->tabsToLinks();
475}
476
477IntRect ChromeClientImpl::windowResizerRect() const
478{
479    IntRect result;
480    if (m_webView->client())
481        result = m_webView->client()->windowResizerRect();
482    return result;
483}
484
485void ChromeClientImpl::invalidateContentsAndRootView(const IntRect& updateRect)
486{
487    if (updateRect.isEmpty())
488        return;
489    m_webView->invalidateRect(updateRect);
490}
491
492void ChromeClientImpl::invalidateContentsForSlowScroll(const IntRect& updateRect)
493{
494    invalidateContentsAndRootView(updateRect);
495}
496
497void ChromeClientImpl::scheduleAnimation()
498{
499    m_webView->scheduleAnimation();
500}
501
502IntRect ChromeClientImpl::rootViewToScreen(const IntRect& rect) const
503{
504    IntRect screenRect(rect);
505
506    if (m_webView->client()) {
507        WebRect windowRect = m_webView->client()->windowRect();
508        screenRect.move(windowRect.x, windowRect.y);
509    }
510
511    return screenRect;
512}
513
514WebScreenInfo ChromeClientImpl::screenInfo() const
515{
516    return m_webView->client() ? m_webView->client()->screenInfo() : WebScreenInfo();
517}
518
519void ChromeClientImpl::contentsSizeChanged(LocalFrame* frame, const IntSize& size) const
520{
521    m_webView->didChangeContentsSize();
522
523    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
524    webframe->didChangeContentsSize(size);
525
526    frame->loader().restoreScrollPositionAndViewState();
527}
528
529void ChromeClientImpl::deviceOrPageScaleFactorChanged() const
530{
531    m_webView->deviceOrPageScaleFactorChanged();
532}
533
534void ChromeClientImpl::layoutUpdated(LocalFrame* frame) const
535{
536    m_webView->layoutUpdated(WebLocalFrameImpl::fromFrame(frame));
537}
538
539void ChromeClientImpl::mouseDidMoveOverElement(
540    const HitTestResult& result, unsigned modifierFlags)
541{
542    if (!m_webView->client())
543        return;
544
545    WebURL url;
546    // Find out if the mouse is over a link, and if so, let our UI know...
547    if (result.isLiveLink() && !result.absoluteLinkURL().string().isEmpty()) {
548        url = result.absoluteLinkURL();
549    } else if (result.innerNonSharedNode()
550        && (isHTMLObjectElement(*result.innerNonSharedNode())
551            || isHTMLEmbedElement(*result.innerNonSharedNode()))) {
552        RenderObject* object = result.innerNonSharedNode()->renderer();
553        if (object && object->isWidget()) {
554            Widget* widget = toRenderWidget(object)->widget();
555            if (widget && widget->isPluginContainer()) {
556                WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
557                url = plugin->plugin()->linkAtPosition(result.roundedPointInInnerNodeFrame());
558            }
559        }
560    }
561
562    m_webView->client()->setMouseOverURL(url);
563}
564
565void ChromeClientImpl::setToolTip(const String& tooltipText, TextDirection dir)
566{
567    if (m_webView->client())
568        m_webView->client()->setToolTipText(tooltipText, toWebTextDirection(dir));
569}
570
571void ChromeClientImpl::dispatchViewportPropertiesDidChange(const ViewportDescription& description) const
572{
573    m_webView->updatePageDefinedViewportConstraints(description);
574}
575
576void ChromeClientImpl::print(LocalFrame* frame)
577{
578    if (m_webView->client())
579        m_webView->client()->printPage(WebLocalFrameImpl::fromFrame(frame));
580}
581
582PassOwnPtr<ColorChooser> ChromeClientImpl::createColorChooser(LocalFrame* frame, ColorChooserClient* chooserClient, const Color&)
583{
584    OwnPtr<ColorChooserUIController> controller;
585    if (RuntimeEnabledFeatures::pagePopupEnabled())
586        controller = adoptPtr(new ColorChooserPopupUIController(frame, this, chooserClient));
587    else
588        controller = adoptPtr(new ColorChooserUIController(frame, chooserClient));
589    controller->openUI();
590    return controller.release();
591}
592
593PassRefPtr<DateTimeChooser> ChromeClientImpl::openDateTimeChooser(DateTimeChooserClient* pickerClient, const DateTimeChooserParameters& parameters)
594{
595#if ENABLE(INPUT_MULTIPLE_FIELDS_UI)
596    return DateTimeChooserImpl::create(this, pickerClient, parameters);
597#else
598    return ExternalDateTimeChooser::create(this, m_webView->client(), pickerClient, parameters);
599#endif
600}
601
602void ChromeClientImpl::runOpenPanel(LocalFrame* frame, PassRefPtr<FileChooser> fileChooser)
603{
604    WebViewClient* client = m_webView->client();
605    if (!client)
606        return;
607
608    WebFileChooserParams params;
609    params.multiSelect = fileChooser->settings().allowsMultipleFiles;
610    params.directory = fileChooser->settings().allowsDirectoryUpload;
611    params.acceptTypes = fileChooser->settings().acceptTypes();
612    params.selectedFiles = fileChooser->settings().selectedFiles;
613    if (params.selectedFiles.size() > 0)
614        params.initialValue = params.selectedFiles[0];
615    params.useMediaCapture = fileChooser->settings().useMediaCapture;
616
617    WebFileChooserCompletionImpl* chooserCompletion =
618        new WebFileChooserCompletionImpl(fileChooser);
619
620    if (client->runFileChooser(params, chooserCompletion))
621        return;
622
623    // Choosing failed, so do callback with an empty list.
624    chooserCompletion->didChooseFile(WebVector<WebString>());
625}
626
627void ChromeClientImpl::enumerateChosenDirectory(FileChooser* fileChooser)
628{
629    WebViewClient* client = m_webView->client();
630    if (!client)
631        return;
632
633    WebFileChooserCompletionImpl* chooserCompletion =
634        new WebFileChooserCompletionImpl(fileChooser);
635
636    ASSERT(fileChooser && fileChooser->settings().selectedFiles.size());
637
638    // If the enumeration can't happen, call the callback with an empty list.
639    if (!client->enumerateChosenDirectory(fileChooser->settings().selectedFiles[0], chooserCompletion))
640        chooserCompletion->didChooseFile(WebVector<WebString>());
641}
642
643void ChromeClientImpl::setCursor(const Cursor& cursor)
644{
645    setCursor(WebCursorInfo(cursor));
646}
647
648void ChromeClientImpl::setCursor(const WebCursorInfo& cursor)
649{
650#if OS(MACOSX)
651    // On Mac the mousemove event propagates to both the popup and main window.
652    // If a popup is open we don't want the main window to change the cursor.
653    if (m_webView->hasOpenedPopup())
654        return;
655#endif
656    if (m_webView->client())
657        m_webView->client()->didChangeCursor(cursor);
658}
659
660void ChromeClientImpl::setCursorForPlugin(const WebCursorInfo& cursor)
661{
662    setCursor(cursor);
663}
664
665void ChromeClientImpl::postAccessibilityNotification(AXObject* obj, AXObjectCache::AXNotification notification)
666{
667    // Alert assistive technology about the accessibility object notification.
668    if (!obj || !obj->document())
669        return;
670
671    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(obj->document()->axObjectCacheOwner().frame());
672    if (webframe && webframe->client())
673        webframe->client()->postAccessibilityEvent(WebAXObject(obj), toWebAXEvent(notification));
674
675    // FIXME: delete these lines once Chrome only uses the frame client interface, above.
676    if (m_webView->client())
677        m_webView->client()->postAccessibilityEvent(WebAXObject(obj), toWebAXEvent(notification));
678}
679
680String ChromeClientImpl::acceptLanguages()
681{
682    return m_webView->client()->acceptLanguages();
683}
684
685bool ChromeClientImpl::paintCustomOverhangArea(GraphicsContext* context, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect)
686{
687    LocalFrame* frame = m_webView->mainFrameImpl()->frame();
688    WebPluginContainerImpl* pluginContainer = WebLocalFrameImpl::pluginContainerFromFrame(frame);
689    if (pluginContainer)
690        return pluginContainer->paintCustomOverhangArea(context, horizontalOverhangArea, verticalOverhangArea, dirtyRect);
691    return false;
692}
693
694GraphicsLayerFactory* ChromeClientImpl::graphicsLayerFactory() const
695{
696    return m_webView->graphicsLayerFactory();
697}
698
699void ChromeClientImpl::attachRootGraphicsLayer(GraphicsLayer* rootLayer)
700{
701    m_webView->setRootGraphicsLayer(rootLayer);
702}
703
704void ChromeClientImpl::enterFullScreenForElement(Element* element)
705{
706    m_webView->enterFullScreenForElement(element);
707}
708
709void ChromeClientImpl::exitFullScreenForElement(Element* element)
710{
711    m_webView->exitFullScreenForElement(element);
712}
713
714void ChromeClientImpl::clearCompositedSelectionBounds()
715{
716    m_webView->clearCompositedSelectionBounds();
717}
718
719void ChromeClientImpl::updateCompositedSelectionBounds(const CompositedSelectionBound& anchor, const CompositedSelectionBound& focus)
720{
721    m_webView->updateCompositedSelectionBounds(toWebSelectionBound(anchor), toWebSelectionBound(focus));
722}
723
724bool ChromeClientImpl::hasOpenedPopup() const
725{
726    return m_webView->hasOpenedPopup();
727}
728
729PassRefPtrWillBeRawPtr<PopupMenu> ChromeClientImpl::createPopupMenu(LocalFrame& frame, PopupMenuClient* client) const
730{
731    if (WebViewImpl::useExternalPopupMenus())
732        return adoptRefWillBeNoop(new ExternalPopupMenu(frame, client, *m_webView));
733
734    return adoptRefWillBeNoop(new PopupMenuChromium(frame, client));
735}
736
737PagePopup* ChromeClientImpl::openPagePopup(PagePopupClient* client, const IntRect& originBoundsInRootView)
738{
739    ASSERT(m_pagePopupDriver);
740    return m_pagePopupDriver->openPagePopup(client, originBoundsInRootView);
741}
742
743void ChromeClientImpl::closePagePopup(PagePopup* popup)
744{
745    ASSERT(m_pagePopupDriver);
746    m_pagePopupDriver->closePagePopup(popup);
747}
748
749void ChromeClientImpl::setPagePopupDriver(PagePopupDriver* driver)
750{
751    ASSERT(driver);
752    m_pagePopupDriver = driver;
753}
754
755void ChromeClientImpl::resetPagePopupDriver()
756{
757    m_pagePopupDriver = m_webView;
758}
759
760bool ChromeClientImpl::shouldRunModalDialogDuringPageDismissal(const DialogType& dialogType, const String& dialogMessage, Document::PageDismissalType dismissalType) const
761{
762    const char* kDialogs[] = {"alert", "confirm", "prompt", "showModalDialog"};
763    int dialog = static_cast<int>(dialogType);
764    ASSERT_WITH_SECURITY_IMPLICATION(0 <= dialog && dialog < static_cast<int>(arraysize(kDialogs)));
765
766    const char* kDismissals[] = {"beforeunload", "pagehide", "unload"};
767    int dismissal = static_cast<int>(dismissalType) - 1; // Exclude NoDismissal.
768    ASSERT_WITH_SECURITY_IMPLICATION(0 <= dismissal && dismissal < static_cast<int>(arraysize(kDismissals)));
769
770    Platform::current()->histogramEnumeration("Renderer.ModalDialogsDuringPageDismissal", dismissal * arraysize(kDialogs) + dialog, arraysize(kDialogs) * arraysize(kDismissals));
771
772    String message = String("Blocked ") + kDialogs[dialog] + "('" + dialogMessage + "') during " + kDismissals[dismissal] + ".";
773    m_webView->mainFrame()->addMessageToConsole(WebConsoleMessage(WebConsoleMessage::LevelError, message));
774
775    return false;
776}
777
778void ChromeClientImpl::needTouchEvents(bool needsTouchEvents)
779{
780    m_webView->hasTouchEventHandlers(needsTouchEvents);
781}
782
783void ChromeClientImpl::setTouchAction(TouchAction touchAction)
784{
785    if (WebViewClient* client = m_webView->client()) {
786        WebTouchAction webTouchAction = static_cast<WebTouchAction>(touchAction);
787        client->setTouchAction(webTouchAction);
788    }
789}
790
791bool ChromeClientImpl::requestPointerLock()
792{
793    return m_webView->requestPointerLock();
794}
795
796void ChromeClientImpl::requestPointerUnlock()
797{
798    return m_webView->requestPointerUnlock();
799}
800
801void ChromeClientImpl::annotatedRegionsChanged()
802{
803    WebViewClient* client = m_webView->client();
804    if (client)
805        client->draggableRegionsChanged();
806}
807
808void ChromeClientImpl::didAssociateFormControls(const WillBeHeapVector<RefPtrWillBeMember<Element> >& elements)
809{
810    if (m_webView->autofillClient())
811        m_webView->autofillClient()->didAssociateFormControls(elements);
812}
813
814void ChromeClientImpl::didCancelCompositionOnSelectionChange()
815{
816    if (m_webView->client())
817        m_webView->client()->didCancelCompositionOnSelectionChange();
818}
819
820void ChromeClientImpl::willSetInputMethodState()
821{
822    if (m_webView->client())
823        m_webView->client()->resetInputMethod();
824}
825
826void ChromeClientImpl::didUpdateTextOfFocusedElementByNonUserInput()
827{
828    if (m_webView->client())
829        m_webView->client()->didUpdateTextOfFocusedElementByNonUserInput();
830}
831
832void ChromeClientImpl::showImeIfNeeded()
833{
834    if (m_webView->client())
835        m_webView->client()->showImeIfNeeded();
836}
837
838void ChromeClientImpl::handleKeyboardEventOnTextField(HTMLInputElement& inputElement, KeyboardEvent& event)
839{
840    if (!m_webView->autofillClient())
841        return;
842    m_webView->autofillClient()->textFieldDidReceiveKeyDown(WebInputElement(&inputElement), WebKeyboardEventBuilder(event));
843}
844
845// FIXME: Remove this code once we have input routing in the browser
846// process. See http://crbug.com/339659.
847void ChromeClientImpl::forwardInputEvent(
848    Frame* frame, Event* event)
849{
850    // FIXME: Input event forwarding to out-of-process frames is broken until
851    // WebRemoteFrameImpl has a WebFrameClient.
852    if (frame->isRemoteFrame())
853        return;
854
855    WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(toLocalFrame(frame));
856
857    // This is only called when we have out-of-process iframes, which
858    // need to forward input events across processes.
859    // FIXME: Add a check for out-of-process iframes enabled.
860    if (event->isKeyboardEvent()) {
861        WebKeyboardEventBuilder webEvent(*static_cast<KeyboardEvent*>(event));
862        webFrame->client()->forwardInputEvent(&webEvent);
863    } else if (event->isMouseEvent()) {
864        WebMouseEventBuilder webEvent(webFrame->frameView(), frame->ownerRenderer(), *static_cast<MouseEvent*>(event));
865        // Internal Blink events should not be forwarded.
866        if (webEvent.type == WebInputEvent::Undefined)
867            return;
868
869        webFrame->client()->forwardInputEvent(&webEvent);
870    } else if (event->isWheelEvent()) {
871        WebMouseWheelEventBuilder webEvent(webFrame->frameView(), frame->ownerRenderer(), *static_cast<WheelEvent*>(event));
872        if (webEvent.type == WebInputEvent::Undefined)
873            return;
874        webFrame->client()->forwardInputEvent(&webEvent);
875    }
876}
877
878void ChromeClientImpl::didChangeValueInTextField(HTMLFormControlElement& element)
879{
880    if (!m_webView->autofillClient())
881        return;
882    m_webView->autofillClient()->textFieldDidChange(WebFormControlElement(&element));
883}
884
885void ChromeClientImpl::didEndEditingOnTextField(HTMLInputElement& inputElement)
886{
887    if (m_webView->autofillClient())
888        m_webView->autofillClient()->textFieldDidEndEditing(WebInputElement(&inputElement));
889}
890
891void ChromeClientImpl::openTextDataListChooser(HTMLInputElement& input)
892{
893    if (m_webView->autofillClient())
894        m_webView->autofillClient()->openTextDataListChooser(WebInputElement(&input));
895}
896
897} // namespace blink
898