Expose NavigatorHost via Embed() rather than globally.

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/c/system/main.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_runner_chromium.h"
 #include "mojo/public/cpp/application/interface_factory_impl.h"
+#include "mojo/public/cpp/application/service_provider_impl.h"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/input_events/input_events_type_converters.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "mojo/services/public/cpp/view_manager/view_manager.h"
 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
 #include "mojo/services/public/cpp/view_manager/view_observer.h"
 #include "mojo/services/public/cpp/view_manager/window_manager_delegate.h"
 #include "mojo/services/public/interfaces/input_events/input_events.mojom.h"
 #include "mojo/services/public/interfaces/launcher/launcher.mojom.h"
 #include "mojo/services/public/interfaces/navigation/navigation.mojom.h"
@@ skipping 33 matching lines @@
   virtual void ShowKeyboard(Id view_id, RectPtr bounds) OVERRIDE;
   virtual void HideKeyboard(Id view_id) OVERRIDE;
 
   WindowManager* window_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerConnection);
 };
 
 class NavigatorHostImpl : public InterfaceImpl<NavigatorHost> {
  public:
-  explicit NavigatorHostImpl(WindowManager* window_manager)
-      : window_manager_(window_manager) {}
+  explicit NavigatorHostImpl(WindowManager* window_manager, Id view_id)
+      : window_manager_(window_manager), view_id_(view_id) {}
   virtual ~NavigatorHostImpl() {
   }
 
  private:
-  virtual void DidNavigateLocally(uint32 source_view_id,
-                                  const mojo::String& url) OVERRIDE;
+  virtual void DidNavigateLocally(const mojo::String& url) OVERRIDE;
   virtual void RequestNavigate(
-      uint32 source_view_id,
       Target target,
       NavigationDetailsPtr nav_details) OVERRIDE;
+
   WindowManager* window_manager_;
+  Id view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigatorHostImpl);
 };
 
 class KeyboardManager : public KeyboardClient,
                         public ViewObserver {
  public:
   KeyboardManager() : view_manager_(NULL), view_(NULL) {
   }
   virtual ~KeyboardManager() {
@@ skipping 150 matching lines @@
 
   View* root_;
   ViewManager* view_manager_;
   const Id content_view_id_;
   const Id launcher_ui_view_id_;
   const Id control_panel_view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RootLayoutManager);
 };
 
+class Window : public InterfaceFactory<NavigatorHost> {
+ public:
+  Window(WindowManager* window_manager, View* view)
+      : window_manager_(window_manager), view_(view) {}
+
+  virtual ~Window() {}
+
+  View* view() const { return view_; }
+
+  void Embed(const std::string& url) {
+    scoped_ptr<ServiceProviderImpl> service_provider_impl(
+        new ServiceProviderImpl());
+    service_provider_impl->AddService<NavigatorHost>(this);
+    view_->Embed(url, service_provider_impl.Pass());
+  }
+
+ private:
+  // InterfaceFactory<NavigatorHost>
+  virtual void Create(ApplicationConnection* connection,
+                      InterfaceRequest<NavigatorHost> request) OVERRIDE {
+    BindToRequest(new NavigatorHostImpl(window_manager_, view_->id()),
+                  &request);
+  }
+
+  WindowManager* window_manager_;
+  View* view_;
+};
+
 class WindowManager
     : public ApplicationDelegate,
       public DebugPanel::Delegate,
       public ViewManagerDelegate,
       public WindowManagerDelegate,
       public ui::EventHandler {
  public:
   WindowManager()
       : window_manager_factory_(this),
-        navigator_host_factory_(this),
         launcher_ui_(NULL),
         view_manager_(NULL),
         window_manager_app_(new WindowManagerApp(this, this)),
         app_(NULL) {}
 
   virtual ~WindowManager() {
     // host() may be destroyed by the time we get here.
     // TODO: figure out a way to always cleanly remove handler.
     if (window_manager_app_->host())
       window_manager_app_->host()->window()->RemovePreTargetHandler(this);
   }
 
   void CloseWindow(Id view_id) {
-    View* view = view_manager_->GetViewById(view_id);
-    DCHECK(view);
-    std::vector<View*>::iterator iter =
-        std::find(windows_.begin(), windows_.end(), view);
+    WindowVector::iterator iter = GetWindowByViewId(view_id);
     DCHECK(iter != windows_.end());
     windows_.erase(iter);
-    view->Destroy();
+    (*iter)->view()->Destroy();
   }
 
   void ShowKeyboard(Id view_id, const gfx::Rect& bounds) {
     // TODO: this needs to validate |view_id|. That is, it shouldn't assume
     // |view_id| is valid and it also needs to make sure the client that sent
     // this really owns |view_id|.
     // TODO: honor |bounds|.
     if (!keyboard_manager_) {
       keyboard_manager_.reset(new KeyboardManager);
       View* parent = view_manager_->GetRoots().back();
@@ skipping 15 matching lines @@
   }
 
   void DidNavigateLocally(uint32 source_view_id, const mojo::String& url) {
     LOG(ERROR) << "DidNavigateLocally: source_view_id: " << source_view_id
                << " url: " << url.To<std::string>();
   }
 
   // Overridden from DebugPanel::Delegate:
   virtual void CloseTopWindow() OVERRIDE {
     if (!windows_.empty())
-      CloseWindow(windows_.back()->id());
+      CloseWindow(windows_.back()->view()->id());
   }
 
   virtual void RequestNavigate(
     uint32 source_view_id,
     Target target,
     NavigationDetailsPtr nav_details) OVERRIDE {
     OnLaunch(source_view_id, target, nav_details->request->url);
   }
 
  private:
+  typedef std::vector<Window*> WindowVector;
+
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* app) MOJO_OVERRIDE {
     app_ = app;
     views_init_.reset(new ViewsInit);
     window_manager_app_->Initialize(app);
   }
 
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
       MOJO_OVERRIDE {
     connection->AddService(&window_manager_factory_);
-    connection->AddService(&navigator_host_factory_);
     window_manager_app_->ConfigureIncomingConnection(connection);
     return true;
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnEmbed(ViewManager* view_manager,
                        View* root,
                        ServiceProviderImpl* exported_services,
                        scoped_ptr<ServiceProvider> imported_services) OVERRIDE {
     DCHECK(!view_manager_);
@@ skipping 21 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);
+    const Id kInvalidSourceViewId = 0;
+    OnLaunch(kInvalidSourceViewId, TARGET_DEFAULT, url);
   }
   virtual void DispatchEvent(EventPtr event) MOJO_OVERRIDE {}
 
   // Overridden from ui::EventHandler:
   virtual void OnEvent(ui::Event* event) OVERRIDE {
     View* view = WindowManagerApp::GetViewForWindow(
         static_cast<aura::Window*>(event->target()));
     if (event->type() == ui::ET_MOUSE_PRESSED &&
         !IsDescendantOfKeyboard(view)) {
       view->SetFocus();
     }
   }
 
   void OnLaunch(uint32 source_view_id,
                 Target requested_target,
                 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;
+    Window* 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();
+      WindowVector::iterator source_view = GetWindowByViewId(source_view_id);
+      bool app_initiated = source_view != windows_.end();
       if (app_initiated)
-        dest_view = source_view;
+        dest_view = *source_view;
       else if (!windows_.empty())
         dest_view = windows_.back();
     }
 
-    if (dest_view)
-      dest_view->Embed(url);
-    else
-      CreateWindow(url);
+    if (!dest_view) {
+      dest_view = CreateWindow();
+      windows_.push_back(dest_view);
+    }
+
+    dest_view->Embed(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);
-    return launcher_ui_->id();
+    launcher_ui_ = CreateWindow(bounds);
+    launcher_ui_->Embed("mojo:mojo_browser");
+    return launcher_ui_->view()->id();
   }
 
-  void CreateWindow(const std::string& url) {
+  Window* CreateWindow() {
     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();
+      gfx::Point position = windows_.back()->view()->bounds().origin();
       position.Offset(35, 35);
       bounds.set_origin(position);
     }
-    windows_.push_back(CreateChild(content_view_id_, url, bounds));
+    return CreateWindow(bounds);
   }
 
-  View* CreateChild(Id parent_id,
-                    const std::string& url,
-                    const gfx::Rect& bounds) {
-    View* view = view_manager_->GetViewById(parent_id);
-    View* embedded = View::Create(view_manager_);
-    view->AddChild(embedded);
-    embedded->SetBounds(bounds);
-    embedded->Embed(url);
-    embedded->SetFocus();
-    return embedded;
+  Window* CreateWindow(const gfx::Rect& bounds) {
+    View* content = view_manager_->GetViewById(content_view_id_);
+    View* view = View::Create(view_manager_);
+    content->AddChild(view);
+    view->SetBounds(bounds);
+    view->SetFocus();
+    return new Window(this, view);
   }
 
   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();
   }
 
+  WindowVector::iterator GetWindowByViewId(Id view_id) {
+    for (std::vector<Window*>::iterator iter = windows_.begin();
+         iter != windows_.end();
+         ++iter) {
+      if ((*iter)->view()->id() == view_id) {
+        return iter;
+      }
+    }
+    return windows_.end();
+  }
+
   InterfaceFactoryImplWithContext<WindowManagerConnection, WindowManager>
       window_manager_factory_;
-  InterfaceFactoryImplWithContext<NavigatorHostImpl, WindowManager>
-      navigator_host_factory_;
 
   scoped_ptr<ViewsInit> views_init_;
   DebugPanel* debug_panel_;
-  View* launcher_ui_;
-  std::vector<View*> windows_;
+  Window* launcher_ui_;
+  WindowVector windows_;
   ViewManager* view_manager_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
 
   scoped_ptr<WindowManagerApp> window_manager_app_;
 
   // Id of the view most content is added to. The keyboard is NOT added here.
   Id content_view_id_;
 
   scoped_ptr<KeyboardManager> keyboard_manager_;
   ApplicationImpl* app_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManager);
 };
 
 void WindowManagerConnection::CloseWindow(Id view_id) {
   window_manager_->CloseWindow(view_id);
 }
 
 void WindowManagerConnection::ShowKeyboard(Id view_id, RectPtr bounds) {
   window_manager_->ShowKeyboard(view_id, bounds.To<gfx::Rect>());
 }
 
 void WindowManagerConnection::HideKeyboard(Id view_id) {
   window_manager_->HideKeyboard(view_id);
 }
 
-void NavigatorHostImpl::DidNavigateLocally(uint32 source_view_id,
-                                           const mojo::String& url) {
-  window_manager_->DidNavigateLocally(source_view_id, url);
+void NavigatorHostImpl::DidNavigateLocally(const mojo::String& url) {
+  window_manager_->DidNavigateLocally(view_id_, url);
 }
 
-void NavigatorHostImpl::RequestNavigate(
-    uint32 source_view_id,
-    Target target,
-    NavigationDetailsPtr nav_details) {
-  window_manager_->RequestNavigate(source_view_id, target, nav_details.Pass());
+void NavigatorHostImpl::RequestNavigate(Target target,
+                                        NavigationDetailsPtr nav_details) {
+  window_manager_->RequestNavigate(view_id_, target, nav_details.Pass());
 }
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::WindowManager);
   return runner.Run(shell_handle);
 }