[Payments] Implement openWindow for service worker based payment handler

content/browser/service_worker/service_worker_client_utils.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_client_utils.h"
 
 #include <algorithm>
 #include <tuple>
 
 #include "base/location.h"
@@ skipping 158 matching lines @@
   // explicitly activate the window, which brings Chrome to the front.
   static_cast<WebContentsImpl*>(web_contents)->Activate();
 
   RenderFrameHostImpl* rfhi =
       static_cast<RenderFrameHostImpl*>(web_contents->GetMainFrame());
   new OpenURLObserver(web_contents,
                       rfhi->frame_tree_node()->frame_tree_node_id(), callback);
 }
 
 void OpenWindowOnUI(
-    const GURL& url,
+    const GURL& redirect_url,
+    const GURL& url_to_open,
     const GURL& script_url,
     int worker_process_id,
     const scoped_refptr<ServiceWorkerContextWrapper>& context_wrapper,
     const OpenURLCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserContext* browser_context =
       context_wrapper->storage_partition()
           ? context_wrapper->storage_partition()->browser_context()
           : nullptr;
   // We are shutting down.
   if (!browser_context)
     return;
 
   RenderProcessHost* render_process_host =
       RenderProcessHost::FromID(worker_process_id);
   if (render_process_host->IsForGuestsOnly()) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(callback, ChildProcessHost::kInvalidUniqueID,
                    MSG_ROUTING_NONE));
     return;
   }
 
   OpenURLParams params(
-      url,
+      url_to_open,
       Referrer::SanitizeForRequest(
-          url, Referrer(script_url, blink::kWebReferrerPolicyDefault)),
-      WindowOpenDisposition::NEW_FOREGROUND_TAB,
+          url_to_open, Referrer(script_url, blink::kWebReferrerPolicyDefault)),
+      redirect_url.is_valid() ? WindowOpenDisposition::NEW_POPUP
+                              : WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui::PAGE_TRANSITION_AUTO_TOPLEVEL, true /* is_renderer_initiated */);
 
+  if (redirect_url.is_valid()) {
+    params.redirect_chain.emplace_back(redirect_url);

[falken, 2017/06/01 07:24:07]

Is there a specific reason you must add to the redirect_chain?

If I understand correctly, the flow is:
1) Navigate to site A. Do some action that triggers a payment request.
2) Payment request is dispatched to service worker B. The service worker is
possibly from a different origin.
3) Service worker B wants to open site C. It calls event.openWindow(url)

In this case I think we're creating a new "browsing context" (window) which is
essentially a fresh navigation to C. The redirect chain as used in the code base
is (AFAIK) about HTTP redirects, which isn't really what's happening here. I'm
not sure what OpenURL does with the redirect chain, but it seems safest to just
not touch it.

Relatedly (it's not from this CL) setting the SW script url to the referrer
seems reasonable but I'm not sure it matches the spec. zino@ do you remember
this? It was added in https://codereview.chromium.org/1202453002

[gogerald, 2017/06/01 13:47:36]

Your understanding is correct. Didn't know redirect_chain is only for http
redirects. Thought our usage is kind of user triggered redirection.

If that's the case, then I would like to add a new field "GURL source_url" in
OpenURLParams.

[please use gerrit instead, 2017/06/01 17:50:37]

I would recommend to add "source_type" parameter to the OpenURLParams instead.
That would be an enum with two values: CLIENTS_OPEN_WINDOW and
PAYMENT_REQUEST_EVENT_OPEN_WINDOW. (The latter could also be named
PAYMENT_HANDLER_OPEN_WINDOW, if you prefer.)

[gogerald1, 2017/06/02 03:33:11]

Acknowledged.

+  }
+
   GetContentClient()->browser()->OpenURL(browser_context, params,
                                          base::Bind(&DidOpenURLOnUI, callback));
 }
 
 void NavigateClientOnUI(const GURL& url,
                         const GURL& script_url,
                         int process_id,
                         int frame_id,
                         const OpenURLCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 206 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(blink::kWebServiceWorkerClientTypeWindow,
             provider_host->client_type());
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&FocusOnUI, provider_host->process_id(),
                  provider_host->frame_id(), provider_host->client_uuid()),
       callback);
 }
 
-void OpenWindow(const GURL& url,
+void OpenWindow(const GURL& redirect_url,
+                const GURL& url_to_open,
                 const GURL& script_url,
                 int worker_process_id,
                 const base::WeakPtr<ServiceWorkerContextCore>& context,
                 const NavigationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
-          &OpenWindowOnUI, url, script_url, worker_process_id,
-          make_scoped_refptr(context->wrapper()),
+          &OpenWindowOnUI, redirect_url, url_to_open, script_url,
+          worker_process_id, make_scoped_refptr(context->wrapper()),
           base::Bind(&DidNavigate, context, script_url.GetOrigin(), callback)));
 }
 
 void NavigateClient(const GURL& url,
                     const GURL& script_url,
                     int process_id,
                     int frame_id,
                     const base::WeakPtr<ServiceWorkerContextCore>& context,
                     const NavigationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 49 matching lines @@
     GetWindowClients(controller, options, callback);
     return;
   }
 
   GetNonWindowClients(controller, options, &clients);
   DidGetClients(callback, &clients);
 }
 
 }  // namespace service_worker_client_utils
 }  // namespace content