Mojo: simple iframe support.

mojo/services/html_viewer/html_document_view.cc

 // Copyright 2014 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 "mojo/services/html_viewer/html_document_view.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
@@ skipping 62 matching lines @@
 
   // Otherwise we don't know if we're the right app to handle this request. Ask
   // host to do the navigation for us.
   return false;
 }
 
 }  // namespace
 
 HTMLDocumentView::HTMLDocumentView(ServiceProvider* service_provider,
                                    ViewManager* view_manager)
-    : view_manager_(view_manager),
+    : SimpleFrameClient(service_provider, 0),
+      view_manager_(view_manager),
       web_view_(NULL),
       root_(NULL),
       repaint_pending_(false),
-      navigator_host_(service_provider),
       weak_factory_(this) {
 }
 
 HTMLDocumentView::~HTMLDocumentView() {
   if (web_view_)
     web_view_->close();
   if (root_)
     root_->RemoveObserver(this);
 }
 
 void HTMLDocumentView::AttachToView(View* view) {
   root_ = view;
+  root_id_ = root_->id();
   root_->SetColor(SK_ColorCYAN);  // Dummy background color.
 
   web_view_ = blink::WebView::create(this);
   ConfigureSettings(web_view_->settings());
   web_view_->setMainFrame(blink::WebLocalFrame::create(this));
   web_view_->resize(root_->bounds().size());
 
   root_->AddObserver(this);
 }
 
@@ skipping 28 matching lines @@
 
 bool HTMLDocumentView::allowsBrokenNullLayerTreeView() const {
   // TODO(darin): Switch to using compositor bindings.
   //
   // NOTE: Note to Blink maintainers, feel free to break this code if it is the
   // last NOT using compositor bindings and you want to delete this code path.
   //
   return true;
 }
 
-blink::WebCookieJar* HTMLDocumentView::cookieJar(blink::WebLocalFrame* frame) {
+SimpleFrameClient::SimpleFrameClient(ServiceProvider* service_provider,
+                                     Id root_id)
+    : service_provider_(service_provider),
+      navigator_host_(service_provider),
+      root_id_(root_id) {
+}
+
+SimpleFrameClient::~SimpleFrameClient() {
+}
+
+blink::WebFrame* SimpleFrameClient::createChildFrame(
+    blink::WebLocalFrame* parent,
+    const blink::WebString& frameName) {
+  // TODO(mpcomplete): What happens if root_ is destroyed and the child frames
+  // live on? Can that happen?
+  blink::WebLocalFrame* web_frame =
+      blink::WebLocalFrame::create(new SimpleFrameClient(service_provider_,

[darin (slow to review), 2014/08/14 23:45:52]

why do you need a new WebFrameClient instance per frame? i guess this is with an
eye toward using the View system for each Frame?

[Matt Perry, 2014/08/15 00:40:04]

Doh. I guess you don't. I assumed WebLocalFrame expected a separate client
instance. I'll go the much simpler route and reuse the same client.

+                                                         root_id_));
+  parent->appendChild(web_frame);
+
+  return web_frame;
+}
+
+void SimpleFrameClient::didDisownOpener(blink::WebLocalFrame* frame) {
+}
+
+void SimpleFrameClient::frameDetached(blink::WebFrame* frame) {
+  bool is_subframe = !!frame->parent();
+
+  if (is_subframe)
+    frame->parent()->removeChild(frame);
+
+  // |frame| is invalid after here.
+  frame->close();
+
+  if (is_subframe) {
+    delete this;
+    // Object is invalid after this point.
+  }
+}
+
+void SimpleFrameClient::frameFocused() {
+}
+
+void SimpleFrameClient::willClose(blink::WebFrame* frame) {
+}
+
+blink::WebCookieJar* SimpleFrameClient::cookieJar(blink::WebLocalFrame* frame) {
   // TODO(darin): Blink does not fallback to the Platform provided WebCookieJar.
   // Either it should, as it once did, or we should find another solution here.
   return blink::Platform::current()->cookieJar();
 }
 
-blink::WebNavigationPolicy HTMLDocumentView::decidePolicyForNavigation(
+blink::WebNavigationPolicy SimpleFrameClient::decidePolicyForNavigation(
     blink::WebLocalFrame* frame, blink::WebDataSource::ExtraData* data,
     const blink::WebURLRequest& request, blink::WebNavigationType nav_type,
     blink::WebNavigationPolicy default_policy, bool is_redirect) {
   if (CanNavigateLocally(frame, request))
     return default_policy;
 
   NavigationDetailsPtr nav_details(NavigationDetails::New());
   nav_details->request = URLRequest::From(request);
 
   navigator_host_->RequestNavigate(
-      root_->id(),
+      root_id_,
       WebNavigationPolicyToNavigationTarget(default_policy),
       nav_details.Pass());
 
   return blink::WebNavigationPolicyIgnore;
 }
 
-void HTMLDocumentView::didAddMessageToConsole(
+void SimpleFrameClient::didAddMessageToConsole(
     const blink::WebConsoleMessage& message,
     const blink::WebString& source_name,
     unsigned source_line,
     const blink::WebString& stack_trace) {
 }
 
-void HTMLDocumentView::didNavigateWithinPage(
+void SimpleFrameClient::didNavigateWithinPage(
     blink::WebLocalFrame* frame, const blink::WebHistoryItem& history_item,
     blink::WebHistoryCommitType commit_type) {
-  navigator_host_->DidNavigateLocally(root_->id(),
+  navigator_host_->DidNavigateLocally(root_id_,
                                       history_item.urlString().utf8());
 }
 
 void HTMLDocumentView::OnViewBoundsChanged(View* view,
                                            const gfx::Rect& old_bounds,
                                            const gfx::Rect& new_bounds) {
   DCHECK_EQ(view, root_);
   web_view_->resize(view->bounds().size());
 }
 
 void HTMLDocumentView::OnViewDestroyed(View* view) {
   DCHECK_EQ(view, root_);
   view->RemoveObserver(this);
   root_ = NULL;
+  root_id_ = 0;
 }
 
 void HTMLDocumentView::OnViewInputEvent(View* view, const EventPtr& event) {
   scoped_ptr<blink::WebInputEvent> web_event =
       TypeConverter<EventPtr, scoped_ptr<blink::WebInputEvent> >::ConvertTo(
           event);
   if (web_event)
     web_view_->handleInputEvent(*web_event);
 }
 
 void HTMLDocumentView::Repaint() {
   repaint_pending_ = false;
 
   web_view_->animate(0.0);
   web_view_->layout();
 
   int width = web_view_->size().width;
   int height = web_view_->size().height;
 
   skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(SkCanvas::NewRaster(
       SkImageInfo::MakeN32(width, height, kOpaque_SkAlphaType)));
 
   web_view_->paint(canvas.get(), gfx::Rect(0, 0, width, height));
 
   root_->SetContents(canvas->getDevice()->accessBitmap(false));
 }
 
 }  // namespace mojo