Cleanup: Move PopupOpeningObserver ownership from ChromeClient to ChromeClientImpl.

Source/web/ChromeClientImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  *
  * 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.
@@ skipping 35 matching lines @@
 #include "core/html/HTMLInputElement.h"
 #include "core/html/forms/ColorChooser.h"
 #include "core/html/forms/ColorChooserClient.h"
 #include "core/html/forms/DateTimeChooser.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/compositing/CompositedSelection.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/page/Page.h"
+#include "core/page/PopupOpeningObserver.h"
 #include "modules/accessibility/AXObject.h"
 #include "platform/Cursor.h"
 #include "platform/FileChooser.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/exported/WrappedResourceRequest.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCursorInfo.h"
@@ skipping 307 matching lines @@
     }
 }
 
 bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel()
 {
     return !!m_webView->client();
 }
 
 bool ChromeClientImpl::runBeforeUnloadConfirmPanelInternal(LocalFrame* frame, const String& message)
 {
+    notifyPopupOpeningObservers();
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
 
     bool isReload = false;
     WebDataSource* ds = webframe->provisionalDataSource();
     if (ds)
         isReload = (ds->navigationType() == WebNavigationTypeReload);
 
     if (webframe->client())
         return webframe->client()->runModalBeforeUnloadDialog(isReload, message);
     return false;
 }
 
 void ChromeClientImpl::closeWindowSoon()
 {
     // Make sure this Page can no longer be found by JS.
     Page::ordinaryPages().remove(m_webView->page());
 
     // Make sure that all loading is stopped.  Ensures that JS stops executing!
     m_webView->mainFrame()->stopLoading();
 
     if (m_webView->client())
         m_webView->client()->closeWidgetSoon();
 }
 
 // Although a LocalFrame is passed in, we don't actually use it, since we
 // already know our own m_webView.
 void ChromeClientImpl::runJavaScriptAlertInternal(LocalFrame* frame, const String& message)
 {
+    notifyPopupOpeningObservers();
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->client()) {
         if (WebUserGestureIndicator::isProcessingUserGesture())
             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
         webframe->client()->runModalAlertDialog(message);
     }
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptConfirmInternal(LocalFrame* frame, const String& message)
 {
+    notifyPopupOpeningObservers();
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->client()) {
         if (WebUserGestureIndicator::isProcessingUserGesture())
             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
         return webframe->client()->runModalConfirmDialog(message);
     }
     return false;
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptPromptInternal(LocalFrame* frame, const String& message, const String& defaultValue, String& result)
 {
+    notifyPopupOpeningObservers();
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->client()) {
         if (WebUserGestureIndicator::isProcessingUserGesture())
             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
         WebString actualValue;
         bool ok = webframe->client()->runModalPromptDialog(
             message,
             defaultValue,
             &actualValue);
         if (ok)
@@ skipping 122 matching lines @@
 {
     m_webView->updatePageDefinedViewportConstraints(description);
 }
 
 void ChromeClientImpl::printInternal(LocalFrame* frame)
 {
     if (m_webView->client())
         m_webView->client()->printPage(WebLocalFrameImpl::fromFrame(frame));
 }
 
-PassOwnPtrWillBeRawPtr<ColorChooser> ChromeClientImpl::createColorChooserInternal(LocalFrame* frame, ColorChooserClient* chooserClient, const Color&)
+PassOwnPtrWillBeRawPtr<ColorChooser> ChromeClientImpl::createColorChooser(LocalFrame* frame, ColorChooserClient* chooserClient, const Color&)
 {
+    notifyPopupOpeningObservers();
     OwnPtrWillBeRawPtr<ColorChooserUIController> controller = nullptr;
     if (RuntimeEnabledFeatures::pagePopupEnabled())
         controller = ColorChooserPopupUIController::create(frame, this, chooserClient);
     else
         controller = ColorChooserUIController::create(frame, chooserClient);
     controller->openUI();
     return controller.release();
 }
 
-PassRefPtr<DateTimeChooser> ChromeClientImpl::openDateTimeChooserInternal(DateTimeChooserClient* pickerClient, const DateTimeChooserParameters& parameters)
+PassRefPtr<DateTimeChooser> ChromeClientImpl::openDateTimeChooser(DateTimeChooserClient* pickerClient, const DateTimeChooserParameters& parameters)
 {
+    notifyPopupOpeningObservers();
 #if ENABLE(INPUT_MULTIPLE_FIELDS_UI)
     return DateTimeChooserImpl::create(this, pickerClient, parameters);
 #else
     return ExternalDateTimeChooser::create(this, m_webView->client(), pickerClient, parameters);
 #endif
 }
 
-void ChromeClientImpl::runOpenPanelInternal(LocalFrame* frame, PassRefPtr<FileChooser> fileChooser)
+void ChromeClientImpl::runOpenPanel(LocalFrame* frame, PassRefPtr<FileChooser> fileChooser)
 {
+    notifyPopupOpeningObservers();
     WebViewClient* client = m_webView->client();
     if (!client)
         return;
 
     WebFileChooserParams params;
     params.multiSelect = fileChooser->settings().allowsMultipleFiles;
     params.directory = fileChooser->settings().allowsDirectoryUpload;
     params.acceptTypes = fileChooser->settings().acceptTypes();
     params.selectedFiles = fileChooser->settings().selectedFiles;
     if (params.selectedFiles.size() > 0)
@@ skipping 149 matching lines @@
 void ChromeClientImpl::updateCompositedSelection(const CompositedSelection& selection)
 {
     m_webView->updateCompositedSelection(WebSelection(selection));
 }
 
 bool ChromeClientImpl::hasOpenedPopup() const
 {
     return m_webView->hasOpenedPopup();
 }
 
-PassRefPtrWillBeRawPtr<PopupMenu> ChromeClientImpl::createPopupMenuInternal(LocalFrame& frame, PopupMenuClient* client)
+PassRefPtrWillBeRawPtr<PopupMenu> ChromeClientImpl::createPopupMenu(LocalFrame& frame, PopupMenuClient* client)
 {
+    notifyPopupOpeningObservers();
     if (WebViewImpl::useExternalPopupMenus())
         return adoptRefWillBeNoop(new ExternalPopupMenu(frame, client, *m_webView));
 
     if (RuntimeEnabledFeatures::htmlPopupMenuEnabled() && RuntimeEnabledFeatures::pagePopupEnabled())
         return PopupMenuImpl::create(this, client);
 
     return adoptRefWillBeNoop(new PopupMenuChromium(frame, client));
 }
 
 PagePopup* ChromeClientImpl::openPagePopup(PagePopupClient* client)
@@ skipping 110 matching lines @@
         webframe->autofillClient()->textFieldDidChange(WebFormControlElement(&element));
 }
 
 void ChromeClientImpl::didEndEditingOnTextField(HTMLInputElement& inputElement)
 {
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(inputElement.document().frame());
     if (webframe->autofillClient())
         webframe->autofillClient()->textFieldDidEndEditing(WebInputElement(&inputElement));
 }
 
-void ChromeClientImpl::openTextDataListChooserInternal(HTMLInputElement& input)
+void ChromeClientImpl::openTextDataListChooser(HTMLInputElement& input)
 {
+    notifyPopupOpeningObservers();
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(input.document().frame());
     if (webframe->autofillClient())
         webframe->autofillClient()->openTextDataListChooser(WebInputElement(&input));
 }
 
 void ChromeClientImpl::textFieldDataListChanged(HTMLInputElement& input)
 {
     WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(input.document().frame());
     if (webframe->autofillClient())
         webframe->autofillClient()->dataListOptionsChanged(WebInputElement(&input));
@@ skipping 10 matching lines @@
 {
     if (m_webView->rootGraphicsLayer() && m_webView->layerTreeView())
         m_webView->page()->frameHost().pinchViewport().registerLayersWithTreeView(m_webView->layerTreeView());
 }
 
 void ChromeClientImpl::didUpdateTopControls() const
 {
     m_webView->didUpdateTopControls();
 }
 
+void ChromeClientImpl::registerPopupOpeningObserver(PopupOpeningObserver* observer)
+{
+    ASSERT(observer);
+    m_popupOpeningObservers.append(observer);
+}
+
+void ChromeClientImpl::unregisterPopupOpeningObserver(PopupOpeningObserver* observer)
+{
+    size_t index = m_popupOpeningObservers.find(observer);
+    ASSERT(index != kNotFound);
+    m_popupOpeningObservers.remove(index);
+}
+
+void ChromeClientImpl::notifyPopupOpeningObservers() const
+{
+    const Vector<PopupOpeningObserver*> observers(m_popupOpeningObservers);
+    for (size_t i = 0; i < observers.size(); ++i)

[yosin_UTC9, 2015/06/03 01:03:42]

Can we use range-for?
It seems there are some of them:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[tkent, 2015/06/03 01:21:01]

Yes, we can.  I'll make a general style fix CL later.

+        observers[i]->willOpenPopup();
+}
+
 } // namespace blink