Update view manager to support content handling.

mojo/examples/window_manager/window_manager.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "mojo/examples/keyboard/keyboard.mojom.h"
 #include "mojo/examples/window_manager/debug_panel.h"
 #include "mojo/examples/window_manager/window_manager.mojom.h"
 #include "mojo/public/cpp/application/application_connection.h"
@@ skipping 294 matching lines @@
   // Overridden from DebugPanel::Delegate:
   virtual void CloseTopWindow() OVERRIDE {
     if (!windows_.empty())
       CloseWindow(windows_.back()->id());
   }
 
   virtual void RequestNavigate(
     uint32 source_view_id,
     Target target,
     NavigationDetailsPtr nav_details) OVERRIDE {
-    launcher_->Launch(nav_details.Pass(),
-                      base::Bind(&WindowManager::OnLaunch,
-                                 base::Unretained(this),
-                                 source_view_id,
-                                 target));
+    OnLaunch(source_view_id, target, nav_details->request->url);
   }
 
  private:
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* app) MOJO_OVERRIDE {
     app_ = app;
-    app->ConnectToService("mojo:mojo_launcher", &launcher_);
     views_init_.reset(new ViewsInit);
   }
 
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
       MOJO_OVERRIDE {
     connection->AddService(&window_manager_factory_);
     connection->AddService(&navigator_host_factory_);
     connection->AddService(&view_manager_client_factory_);
     return true;
   }
@@ skipping 27 matching lines @@
   virtual void OnViewManagerDisconnected(ViewManager* view_manager) OVERRIDE {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from WindowManagerDelegate:
   virtual void Embed(
       const String& url,
       InterfaceRequest<ServiceProvider> service_provider) OVERRIDE {
-    CreateWindow(url,
-                 NavigationDetailsPtr().Pass(),
-                 ResponseDetailsPtr().Pass());
+    CreateWindow(url);
   }
   virtual void DispatchEvent(View* target, EventPtr event) OVERRIDE {
     // TODO(beng): More sophisticated focus handling than this is required!
     if (event->action == EVENT_TYPE_MOUSE_PRESSED &&
         !IsDescendantOfKeyboard(target)) {
       target->SetFocus();
     }
     view_manager_->DispatchEvent(target, event.Pass());
   }
 
   void OnLaunch(
       uint32 source_view_id,
       Target requested_target,
-      const mojo::String& handler_url,
-      const mojo::String& view_url,
-      ResponseDetailsPtr response) {
-    // TODO(mpcomplete): This seems to be unused in favor of |response|. We
-    // might need to use it (and fill it in properly, with method, etc) if we
-    // need to preserve that information.
-    NavigationDetailsPtr nav_details(NavigationDetails::New());
-    nav_details->request->url = view_url;
-
+      const mojo::String& url) {
     Target target = debug_panel_->navigation_target();
     if (target == TARGET_DEFAULT) {
       if (requested_target != TARGET_DEFAULT) {
         target = requested_target;
       } else {
         // TODO(aa): Should be TARGET_NEW_NODE if source origin and dest origin
         // are different?
         target = TARGET_SOURCE_NODE;
       }
     }
 
     View* dest_view = NULL;
     if (target == TARGET_SOURCE_NODE) {
       View* source_view = view_manager_->GetViewById(source_view_id);
       bool app_initiated = std::find(windows_.begin(), windows_.end(),
                                      source_view) != windows_.end();
       if (app_initiated)
         dest_view = source_view;
       else if (!windows_.empty())
         dest_view = windows_.back();
     }
 
     if (dest_view)
-      Embed(dest_view, handler_url, nav_details.Pass(), response.Pass());
+      dest_view->Embed(url);
     else
-      CreateWindow(handler_url, nav_details.Pass(), response.Pass());
+      CreateWindow(url);
   }
 
   // TODO(beng): proper layout manager!!
   Id CreateLauncherUI() {
     NavigationDetailsPtr nav_details;
     ResponseDetailsPtr response;
     View* view = view_manager_->GetViewById(content_view_id_);
     gfx::Rect bounds = view->bounds();
     bounds.Inset(kBorderInset, kBorderInset);
     bounds.set_height(kTextfieldHeight);
-    launcher_ui_ = CreateChild(content_view_id_, "mojo:mojo_browser", bounds,
-                               nav_details.Pass(), response.Pass());
+    launcher_ui_ = CreateChild(content_view_id_, "mojo:mojo_browser", bounds);
     return launcher_ui_->id();
   }
 
-  void CreateWindow(const std::string& handler_url,
-                    NavigationDetailsPtr nav_details,
-                    ResponseDetailsPtr response) {
+  void CreateWindow(const std::string& url) {
     View* view = view_manager_->GetViewById(content_view_id_);
     gfx::Rect bounds(kBorderInset,
                      2 * kBorderInset + kTextfieldHeight,
                      view->bounds().width() - 3 * kBorderInset -
                          kControlPanelWidth,
                      view->bounds().height() -
                          (3 * kBorderInset + kTextfieldHeight));
     if (!windows_.empty()) {
       gfx::Point position = windows_.back()->bounds().origin();
       position.Offset(35, 35);
       bounds.set_origin(position);
     }
-    windows_.push_back(CreateChild(content_view_id_, handler_url, bounds,
-                                   nav_details.Pass(), response.Pass()));
+    windows_.push_back(CreateChild(content_view_id_, url, bounds));
   }
 
   View* CreateChild(Id parent_id,
                     const std::string& url,
-                    const gfx::Rect& bounds,
-                    NavigationDetailsPtr nav_details,
-                    ResponseDetailsPtr response) {
+                    const gfx::Rect& bounds) {
     View* view = view_manager_->GetViewById(parent_id);
     View* embedded = View::Create(view_manager_);
     view->AddChild(embedded);
     embedded->SetBounds(bounds);
-    Embed(embedded, url, nav_details.Pass(), response.Pass());
+    embedded->Embed(url);
     embedded->SetFocus();
     return embedded;
   }
 
-  void Embed(View* view, const std::string& app_url,
-             NavigationDetailsPtr nav_details,
-             ResponseDetailsPtr response) {
-    view->Embed(app_url);
-    if (nav_details) {
-      NavigatorPtr navigator;
-      app_->ConnectToService(app_url, &navigator);
-      navigator->Navigate(view->id(), nav_details.Pass(), response.Pass());
-    }
-  }
-
   bool IsDescendantOfKeyboard(View* target) {
     return keyboard_manager_.get() &&
         keyboard_manager_->view()->Contains(target);
   }
 
   Id CreateControlPanel(View* root) {
     View* view = View::Create(view_manager_);
     root->AddChild(view);
 
     gfx::Rect bounds(root->bounds().width() - kControlPanelWidth -
                          kBorderInset,
                      kBorderInset * 2 + kTextfieldHeight,
                      kControlPanelWidth,
                      root->bounds().height() - kBorderInset * 3 -
                          kTextfieldHeight);
     view->SetBounds(bounds);
 
     debug_panel_ = new DebugPanel(this, view);
     return view->id();
   }
 
   InterfaceFactoryImplWithContext<WindowManagerConnection, WindowManager>
       window_manager_factory_;
   InterfaceFactoryImplWithContext<NavigatorHostImpl, WindowManager>
       navigator_host_factory_;
 
   scoped_ptr<ViewsInit> views_init_;
   DebugPanel* debug_panel_;
-  LauncherPtr launcher_;
   View* launcher_ui_;
   std::vector<View*> windows_;
   ViewManager* view_manager_;
   ViewManagerClientFactory view_manager_client_factory_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
 
   // Id of the view most content is added to. The keyboard is NOT added here.
   Id content_view_id_;
 
   scoped_ptr<KeyboardManager> keyboard_manager_;
@@ skipping 27 matching lines @@
 }
 
 }  // namespace examples
 
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
   return new examples::WindowManager;
 }
 
 }  // namespace mojo