ServiceWorker: Fix the bug in navigate() if windowclient is nested frame.

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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_version.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
@@ skipping 146 matching lines @@
 using OpenURLCallback = base::Callback<void(int, int)>;
 
 // The OpenURLObserver class is a WebContentsObserver that will wait for a
 // WebContents to be initialized, run the |callback| passed to its constructor
 // then self destroy.
 // The callback will receive the process and frame ids. If something went wrong
 // those will be (kInvalidUniqueID, MSG_ROUTING_NONE).
 // The callback will be called in the IO thread.
 class OpenURLObserver : public WebContentsObserver {
  public:
-  OpenURLObserver(WebContents* web_contents, const OpenURLCallback& callback)
-      : WebContentsObserver(web_contents), callback_(callback) {}
+  OpenURLObserver(WebContents* web_contents,
+                  RenderFrameHost* render_frame_host,
+                  const OpenURLCallback& callback)
+      : WebContentsObserver(web_contents),
+        render_frame_host_(render_frame_host),
+        callback_(callback) {}
 
   void DidCommitProvisionalLoadForFrame(
       RenderFrameHost* render_frame_host,
       const GURL& validated_url,
       ui::PageTransition transition_type) override {
     DCHECK(web_contents());
 
-    if (render_frame_host != web_contents()->GetMainFrame())
+    if (render_frame_host != render_frame_host_)
       return;
 
     RunCallback(render_frame_host->GetProcess()->GetID(),
                 render_frame_host->GetRoutingID());
   }
 
   void RenderProcessGone(base::TerminationStatus status) override {
     RunCallback(ChildProcessHost::kInvalidUniqueID, MSG_ROUTING_NONE);
   }
 
   void WebContentsDestroyed() override {
     RunCallback(ChildProcessHost::kInvalidUniqueID, MSG_ROUTING_NONE);
   }
 
  private:
   void RunCallback(int render_process_id, int render_frame_id) {
     // After running the callback, |this| will stop observing, thus
     // web_contents() should return nullptr and |RunCallback| should no longer
     // be called. Then, |this| will self destroy.
     DCHECK(web_contents());
 
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(callback_,
                                        render_process_id,
                                        render_frame_id));
     Observe(nullptr);
     base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
+  RenderFrameHost* render_frame_host_;
   const OpenURLCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(OpenURLObserver);
 };
 
 void DidOpenURL(const OpenURLCallback& callback, WebContents* web_contents) {
   DCHECK(web_contents);
 
-  new OpenURLObserver(web_contents, callback);
+  new OpenURLObserver(web_contents, web_contents->GetMainFrame(), callback);
 }
 
 void NavigateClientOnUI(const GURL& url,
                         const GURL& script_url,
                         int process_id,
                         int frame_id,
                         const OpenURLCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  RenderFrameHost* render_frame_host =
-      RenderFrameHost::FromID(process_id, frame_id);
+  RenderFrameHostImpl* render_frame_host =
+      RenderFrameHostImpl::FromID(process_id, frame_id);
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host);
 
   if (!render_frame_host || !web_contents) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(callback, ChildProcessHost::kInvalidUniqueID,
                    MSG_ROUTING_NONE));
     return;
   }
 
-  OpenURLParams params(
-      url, Referrer::SanitizeForRequest(
-               url, Referrer(script_url, blink::WebReferrerPolicyDefault)),
-      CURRENT_TAB, ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
-      true /* is_renderer_initiated */);
-  web_contents->OpenURL(params);
-  DidOpenURL(callback, web_contents);
+  CommonNavigationParams common_params;
+  common_params.url = url;
+  common_params.referrer = Referrer::SanitizeForRequest(
+      url, Referrer(script_url, blink::WebReferrerPolicyDefault)),
+  common_params.transition = ui::PAGE_TRANSITION_AUTO_TOPLEVEL;

[nhiroki, 2015/09/16 08:00:18]

For iframes, the trantition type could be PAGE_TRANSITION_AUTO_SUBFRAME?

[zino, 2015/09/17 01:27:45]

Done.

+  render_frame_host->Navigate(common_params, StartNavigationParams(),

[Charlie Reis, 2015/09/16 18:58:46]

It's generally not ok to directly call RenderFrameHost::Navigate, since that
bypasses NavigationController.

The previous WebContents::OpenURL approach can continue to work if you set the
frame_tree_node_id on the params object.

[zino, 2015/09/17 01:27:45]

Done.

+                              RequestNavigationParams());
+
+  new OpenURLObserver(web_contents, render_frame_host, callback);
 }
 
 void OpenWindowOnUI(
     const GURL& url,
     const GURL& script_url,
     int process_id,
     const scoped_refptr<ServiceWorkerContextWrapper>& context_wrapper,
     const OpenURLCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 2077 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ || running_status() != RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content