Update view_manager and window_manager to make use of content handling.

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"
 #include "base/thread_task_runner_handle.h"
+#include "mojo/public/cpp/application/connect.h"
+#include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/public/cpp/system/data_pipe.h"
+#include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/html_viewer/blink_input_events_type_converters.h"
 #include "mojo/services/html_viewer/blink_url_request_type_converters.h"
 #include "mojo/services/html_viewer/webstoragenamespace_impl.h"
 #include "mojo/services/html_viewer/weburlloader_impl.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "skia/ext/refptr.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@@ skipping 48 matching lines @@
   if (request.extraData())
     return true;
 
   // 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),
-      navigator_host_(service_provider),
+HTMLDocumentView::HTMLDocumentView(
+    URLResponsePtr response,
+    scoped_ptr<ServiceProvider> imported_services,
+    ServiceProviderImpl* exported_services,
+    Shell* shell)
+    : imported_services_(imported_services.Pass()),
+      shell_(shell),
       web_view_(NULL),
       root_(NULL),
+      view_manager_client_factory_(shell, this),
       repaint_pending_(false),
       weak_factory_(this) {
+  exported_services->AddService(&view_manager_client_factory_);
+  Load(response.Pass());
 }
 
 HTMLDocumentView::~HTMLDocumentView() {
   if (web_view_)
     web_view_->close();
   if (root_)
     root_->RemoveObserver(this);
 }
 
-void HTMLDocumentView::AttachToView(View* view) {
-  root_ = view;
+void HTMLDocumentView::OnEmbed(ViewManager* view_manager,
+                               View* root,
+                               ServiceProviderImpl* exported_services,
+                               scoped_ptr<ServiceProvider> imported_services) {
+  root_ = root;
   root_->SetColor(SK_ColorCYAN);  // Dummy background color.
+  web_view_->resize(root_->bounds().size());
+  root_->AddObserver(this);
+}
 
+void HTMLDocumentView::OnViewManagerDisconnected(ViewManager* view_manager) {
+  // TODO(aa): Need to figure out how shutdown works.
+}
+
+void HTMLDocumentView::Load(URLResponsePtr response) {
   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);
-}
-
-void HTMLDocumentView::Load(URLResponsePtr response) {
-  DCHECK(web_view_);
 
   GURL url(response->url);
 
   WebURLRequestExtraData* extra_data = new WebURLRequestExtraData;
   extra_data->synthetic_response = response.Pass();
 
   blink::WebURLRequest web_request;
   web_request.initialize();
   web_request.setURL(url);
   web_request.setExtraData(extra_data);
@@ skipping 48 matching lines @@
 blink::WebNavigationPolicy HTMLDocumentView::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(
+  GetNavigatorHost()->RequestNavigate(
       root_->id(),
       WebNavigationPolicyToNavigationTarget(default_policy),
       nav_details.Pass());
 
   return blink::WebNavigationPolicyIgnore;
 }
 
 void HTMLDocumentView::didAddMessageToConsole(
     const blink::WebConsoleMessage& message,
     const blink::WebString& source_name,
     unsigned source_line,
     const blink::WebString& stack_trace) {
 }
 
 void HTMLDocumentView::didNavigateWithinPage(
     blink::WebLocalFrame* frame, const blink::WebHistoryItem& history_item,
     blink::WebHistoryCommitType commit_type) {
-  navigator_host_->DidNavigateLocally(root_->id(),
-                                      history_item.urlString().utf8());
+  GetNavigatorHost()->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;
 }
 
 void HTMLDocumentView::OnViewInputEvent(View* view, const EventPtr& event) {
   scoped_ptr<blink::WebInputEvent> web_event =
       event.To<scoped_ptr<blink::WebInputEvent> >();
   if (web_event)
     web_view_->handleInputEvent(*web_event);
 }
 
 void HTMLDocumentView::Repaint() {
   repaint_pending_ = false;
 
+  if (!root_)
+    return;
+
   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));
 }
 
+NavigatorHost* HTMLDocumentView::GetNavigatorHost() {
+  if (!navigator_host_.get()) {
+    // TODO(aa): This should come via |imported_services| in OnEmbed().
+    InterfacePtr<ServiceProvider> sp;
+    shell_->ConnectToApplication("mojo:mojo_window_manager", Get(&sp));
+    ConnectToService(sp.get(), &navigator_host_);
+  }
+  return navigator_host_.get();
+}
+
 }  // namespace mojo