Mandoline: html_frame returns WebNavigationPolicyHandledByClient to blink when the navigation reque…

components/html_viewer/html_frame.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 "components/html_viewer/html_frame.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 105 matching lines @@
 
 }  // namespace
 
 HTMLFrame::HTMLFrame(CreateParams* params)
     : frame_tree_manager_(params->manager),
       parent_(params->parent),
       view_(nullptr),
       id_(params->id),
       web_frame_(nullptr),
       delegate_(params->delegate),
+      pending_navigation_(false),
       weak_factory_(this) {
   if (parent_)
     parent_->children_.push_back(this);
 
   if (params->view && params->view->id() == id_)
     SetView(params->view);
 
   SetReplicatedFrameStateFromClientProperties(params->properties, &state_);
 
   if (!parent_) {
@@ skipping 126 matching lines @@
   if (IsLocal())
     return true;
 
   for (HTMLFrame* child : children_) {
     if (child->HasLocalDescendant())
       return true;
   }
   return false;
 }
 
+void HTMLFrame::LoadRequest(const blink::WebURLRequest& request) {
+  DCHECK(IsLocal());
+
+  DVLOG(2) << "HTMLFrame::LoadRequest this=" << this << " id=" << id_
+           << " URL=" << GURL(request.url());
+
+  pending_navigation_ = false;
+  web_frame_->toWebLocalFrame()->loadRequest(request);
+}
+
 HTMLFrame::~HTMLFrame() {
   DVLOG(2) << "~HTMLFrame this=" << this << " id=" << id_;
 
   DCHECK(children_.empty());
 
   if (parent_) {
     auto iter =
         std::find(parent_->children_.begin(), parent_->children_.end(), this);
     parent_->children_.erase(iter);
   }
@@ skipping 85 matching lines @@
     DCHECK_EQ(blink::WebNavigationPolicyCurrentTab, info.defaultPolicy);
     return blink::WebNavigationPolicyCurrentTab;
   }
 
   // about:blank is treated as the same origin and is always allowed for frames.
   if (parent_ && info.urlRequest.url() == GURL(url::kAboutBlankURL) &&
       info.defaultPolicy == blink::WebNavigationPolicyCurrentTab) {
     return blink::WebNavigationPolicyCurrentTab;
   }
 
-  // Ask the Frame to handle the navigation. By returning
-  // WebNavigationPolicyIgnore the load is suppressed.
+  // Ask the Frame to handle the navigation. Returning
+  // WebNavigationPolicyHandledByClient to inform blink that the navigation is
+  // being handled.
+  DVLOG(2) << "HTMLFrame::decidePolicyForNavigation calls "
+           << "Frame::RequestNavigate this=" << this << " id=" << id_
+           << " URL=" << GURL(info.urlRequest.url());
+
   mojo::URLRequestPtr url_request = mojo::URLRequest::From(info.urlRequest);
   server_->RequestNavigate(
       WebNavigationPolicyToNavigationTarget(info.defaultPolicy), id_,
       url_request.Pass());
 
-  return blink::WebNavigationPolicyIgnore;
+  // TODO(yzshen): crbug.com/532556 If the server side drops the request,
+  // this frame will be in permenant-loading state. We should send a
+  // notification to mark this frame as not loading in that case. We also need
+  // to better keep track of multiple pending navigations.
+  pending_navigation_ = true;
+  return blink::WebNavigationPolicyHandledByClient;
+}
+
+bool HTMLFrame::hasPendingNavigation(blink::WebLocalFrame* frame) {
+  return pending_navigation_;
 }
 
 void HTMLFrame::didHandleOnloadEvents(blink::WebLocalFrame* frame) {
   DVLOG(2) << "XXX HTMLFrame::didHandleOnloadEvents id=" << id_;
   static bool recorded = false;
   if (!recorded && startup_performance_data_collector_) {
     startup_performance_data_collector_->SetFirstWebContentsMainFrameLoadTime(
         base::Time::Now().ToInternalValue());
     recorded = true;
   }
@@ skipping 193 matching lines @@
         cc::SurfaceId(owned_view_->view()->id()),
         global_state()->device_pixel_ratio(),
         owned_view_->view()->bounds().To<gfx::Rect>().size());
 
     web_layer_.reset(new cc_blink::WebLayerImpl(surface_layer_));
   }
   remote_frame->setRemoteWebLayer(web_layer_.get());
   remote_frame->setReplicatedName(state_.name);
   remote_frame->setReplicatedOrigin(state_.origin);
   remote_frame->setReplicatedSandboxFlags(state_.sandbox_flags);
+
   // Tell the frame that it is actually loading. This prevents its parent
   // from prematurely dispatching load event.
   remote_frame->didStartLoading();
+  pending_navigation_ = false;
+
   web_frame_ = remote_frame;
   SetView(nullptr);
   server_.reset();
   frame_client_binding_.reset();
   if (delegate)
     delegate->OnFrameSwappedToRemote();
 }
 
 void HTMLFrame::SwapToLocal(
     HTMLFrameDelegate* delegate,
@@ skipping 279 matching lines @@
   if (!surface_layer_)
     return;
 
   surface_layer_->SetSurfaceId(
       cc::SurfaceId(owned_view_->view()->id()),
       global_state()->device_pixel_ratio(),
       owned_view_->view()->bounds().To<gfx::Rect>().size());
 }
 
 }  // namespace mojo