Remove a bunch of dead code around WindowFeatures

third_party/WebKit/Source/core/page/CreateWindow.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 11 matching lines @@
  * 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 "core/page/CreateWindow.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/Document.h"
 #include "core/dom/UserGestureIndicator.h"
+#include "core/events/UIEventWithKeyState.h"
 #include "core/frame/FrameClient.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/WindowFeatures.h"
 #include "core/probe/CoreProbes.h"
+#include "platform/KeyboardCodes.h"
 #include "platform/loader/fetch/ResourceRequest.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
+#include "public/platform/WebInputEvent.h"
+#include "public/platform/WebKeyboardEvent.h"
+#include "public/platform/WebMouseEvent.h"
 #include "public/platform/WebURLRequest.h"
 
 namespace blink {
 
+void UpdatePolicyForEvent(const WebInputEvent* input_event,

[kinuko, 2017/06/01 06:39:28]

nit: put these in anon namespace except for EffectiveNavigationPolicy?

[Nate Chapin, 2017/06/01 20:57:11]

Done.

+                          NavigationPolicy* policy) {
+  if (!input_event)
+    return;
+
+  unsigned short button_number = 0;
+  if (input_event->GetType() == WebInputEvent::kMouseUp) {
+    const WebMouseEvent* mouse_event =
+        static_cast<const WebMouseEvent*>(input_event);
+
+    switch (mouse_event->button) {
+      case WebMouseEvent::Button::kLeft:
+        button_number = 0;
+        break;
+      case WebMouseEvent::Button::kMiddle:
+        button_number = 1;
+        break;
+      case WebMouseEvent::Button::kRight:
+        button_number = 2;
+        break;
+      default:
+        return;
+    }
+  } else if ((WebInputEvent::IsKeyboardEventType(input_event->GetType()) &&
+              static_cast<const WebKeyboardEvent*>(input_event)
+                      ->windows_key_code == VKEY_RETURN) ||
+             WebInputEvent::IsGestureEventType(input_event->GetType())) {
+    // Keyboard and gesture events can simulate mouse events.
+    button_number = 0;
+  } else {
+    return;
+  }
+
+  bool ctrl = input_event->GetModifiers() & WebInputEvent::kControlKey;
+  bool shift = input_event->GetModifiers() & WebInputEvent::kShiftKey;
+  bool alt = input_event->GetModifiers() & WebInputEvent::kAltKey;
+  bool meta = input_event->GetModifiers() & WebInputEvent::kMetaKey;
+
+  NavigationPolicy user_policy = *policy;
+  NavigationPolicyFromMouseEvent(button_number, ctrl, shift, alt, meta,
+                                 &user_policy);
+
+  // When the input event suggests a download, but the navigation was initiated
+  // by script, we should not override it.
+  if (user_policy == kNavigationPolicyDownload &&
+      *policy != kNavigationPolicyIgnore)
+    return;
+
+  // User and app agree that we want a new window; let the app override the
+  // decorations.
+  if (user_policy == kNavigationPolicyNewWindow &&
+      *policy == kNavigationPolicyNewPopup)
+    return;
+  *policy = user_policy;
+}
+
+NavigationPolicy GetNavigationPolicy(const WebInputEvent* current_event,
+                                     bool toolbar_visible) {
+  // If the window features didn't enable the toolbar, or this window wasn't
+  // created by a user gesture, show as a popup instead of a new tab.
+  //
+  // Note: this previously also checked that menubar, resizable, scrollbar, and
+  // statusbar are enabled too. When no feature string is specified, these
+  // features default to enabled (and the window opens as a new tab). However,
+  // when a feature string is specified, any *unspecified* features default to
+  // disabled, often causing the window to open as a popup instead.
+  //
+  // As specifying menubar, resizable, scrollbar, and statusbar have no effect
+  // on the UI, just ignore them and only consider whether or not the toolbar is
+  // enabled, which matches Firefox's behavior.
+  NavigationPolicy policy = toolbar_visible ? kNavigationPolicyNewForegroundTab
+                                            : kNavigationPolicyNewPopup;
+  UpdatePolicyForEvent(current_event, &policy);
+  return policy;
+}
+
+NavigationPolicy EffectiveNavigationPolicy(NavigationPolicy policy,
+                                           const WebInputEvent* current_event,
+                                           bool toolbar_visible) {
+  if (policy == kNavigationPolicyIgnore)
+    return GetNavigationPolicy(current_event, toolbar_visible);
+  if (policy == kNavigationPolicyNewBackgroundTab &&
+      GetNavigationPolicy(current_event, toolbar_visible) !=
+          kNavigationPolicyNewBackgroundTab &&
+      !UIEventWithKeyState::NewTabModifierSetFromIsolatedWorld()) {
+    return kNavigationPolicyNewForegroundTab;
+  }
+  return policy;
+}
+
 static Frame* ReuseExistingWindow(LocalFrame& active_frame,
                                   LocalFrame& lookup_frame,
                                   const AtomicString& frame_name,
                                   NavigationPolicy policy) {
   if (!frame_name.IsEmpty() && !EqualIgnoringASCIICase(frame_name, "_blank") &&
       policy == kNavigationPolicyIgnore) {
     if (Frame* frame =
             lookup_frame.FindFrameForNavigation(frame_name, active_frame)) {
       if (!EqualIgnoringASCIICase(frame_name, "_self")) {
         if (Page* page = frame->GetPage()) {
@@ skipping 11 matching lines @@
 
 static Frame* CreateNewWindow(LocalFrame& opener_frame,
                               const FrameLoadRequest& request,
                               const WindowFeatures& features,
                               NavigationPolicy policy,
                               bool& created) {
   Page* old_page = opener_frame.GetPage();
   if (!old_page)
     return nullptr;
 
+  policy = EffectiveNavigationPolicy(

[Nate Chapin, 2017/05/31 16:55:13]

Bonus of calling this: here we only need to do it once, instead of separate
invocations in CreateWindow() and Show().

+      policy, old_page->GetChromeClient().GetCurrentInputEvent(),
+      features.tool_bar_visible);
+
   Page* page = old_page->GetChromeClient().CreateWindow(&opener_frame, request,
                                                         features, policy);
   if (!page)
     return nullptr;
 
   if (page == old_page)
     return &opener_frame.Tree().Top();
 
   DCHECK(page->MainFrame());
   LocalFrame& frame = *ToLocalFrame(page->MainFrame());
 
   if (!EqualIgnoringASCIICase(request.FrameName(), "_blank"))
     frame.Tree().SetName(request.FrameName());
 
-  page->GetChromeClient().SetWindowFeatures(features);
+  page->SetWindowFeatures(features);
+
+  frame.View()->SetCanHaveScrollbars(features.scrollbars_visible);

[Nate Chapin, 2017/05/31 16:55:12]

This was a side effect of ChromeClientImpl::SetScrollbarsVisible

 
   // 'x' and 'y' specify the location of the window, while 'width' and 'height'
   // specify the size of the viewport. We can only resize the window, so adjust
   // for the difference between the window size and the viewport size.
 
   IntRect window_rect = page->GetChromeClient().RootWindowRect();
   IntSize viewport_size = page->GetChromeClient().PageRect().Size();
 
   if (features.x_set)
     window_rect.SetX(features.x);
@@ skipping 20 matching lines @@
   return &frame;
 }
 
 static Frame* CreateWindowHelper(LocalFrame& opener_frame,
                                  LocalFrame& active_frame,
                                  LocalFrame& lookup_frame,
                                  const FrameLoadRequest& request,
                                  const WindowFeatures& features,
                                  NavigationPolicy policy,
                                  bool& created) {
-  DCHECK(!features.dialog || request.FrameName().IsEmpty());
   DCHECK(request.GetResourceRequest().RequestorOrigin() ||
          opener_frame.GetDocument()->Url().IsEmpty());
   DCHECK_EQ(request.GetResourceRequest().GetFrameType(),
             WebURLRequest::kFrameTypeAuxiliary);
 
   created = false;
 
   Frame* window = features.noopener
                       ? nullptr
                       : ReuseExistingWindow(active_frame, lookup_frame,
@@ skipping 142 matching lines @@
   }
 
   // TODO(japhet): Form submissions on RemoteFrames don't work yet.
   FrameLoadRequest new_request(0, request.GetResourceRequest());
   new_request.SetForm(request.Form());
   if (new_frame->IsLocalFrame())
     ToLocalFrame(new_frame)->Loader().Load(new_request);
 }
 
 }  // namespace blink