Mojo: Use InterfaceFactory<Interface> for service registration

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"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
+#include "mojo/public/cpp/bindings/interface_factory_with_context.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/node.h"
 #include "mojo/services/public/cpp/view_manager/node_observer.h"
 #include "mojo/services/public/cpp/view_manager/view.h"
 #include "mojo/services/public/cpp/view_manager/view_event_dispatcher.h"
 #include "mojo/services/public/cpp/view_manager/view_manager.h"
+#include "mojo/services/public/cpp/view_manager/view_manager_client_factory.h"
 #include "mojo/services/public/cpp/view_manager/view_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"
 #include "mojo/views/views_init.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 #if defined CreateWindow
 #undef CreateWindow
 #endif
 
 using mojo::view_manager::Id;
 using mojo::view_manager::Node;
 using mojo::view_manager::NodeObserver;
 using mojo::view_manager::View;
 using mojo::view_manager::ViewEventDispatcher;
 using mojo::view_manager::ViewManager;
+using mojo::view_manager::ViewManagerClientFactory;
 using mojo::view_manager::ViewManagerDelegate;
 using mojo::view_manager::ViewObserver;
 
 namespace mojo {
 namespace examples {
 
 class WindowManager;
 
 namespace {
 
 const int kBorderInset = 25;
 const int kControlPanelWidth = 200;
 const int kTextfieldHeight = 25;
 
 }  // namespace
 
 class WindowManagerConnection : public InterfaceImpl<IWindowManager> {
  public:
-  explicit WindowManagerConnection(ApplicationConnection* connection,
-                                   WindowManager* window_manager)
+  explicit WindowManagerConnection(WindowManager* window_manager)
       : window_manager_(window_manager) {}
   virtual ~WindowManagerConnection() {}
 
  private:
   // Overridden from IWindowManager:
   virtual void CloseWindow(Id node_id) OVERRIDE;
   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 NavigatorHost : public InterfaceImpl<navigation::NavigatorHost> {
  public:
-  explicit NavigatorHost(ApplicationConnection* connection,
-                         WindowManager* window_manager)
-      : window_manager_(window_manager) {
-  }
+  explicit NavigatorHost(WindowManager* window_manager)
+      : window_manager_(window_manager) {}
   virtual ~NavigatorHost() {
   }
 
  private:
   virtual void DidNavigateLocally(uint32 source_node_id,
                                   const mojo::String& url) OVERRIDE;
   virtual void RequestNavigate(
       uint32 source_node_id,
       navigation::Target target,
       navigation::NavigationDetailsPtr nav_details) OVERRIDE;
@@ skipping 153 matching lines @@
 
   Node* root_;
   ViewManager* view_manager_;
   const Id content_node_id_;
   const Id launcher_ui_node_id_;
   const Id control_panel_node_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RootLayoutManager);
 };
 
-class WindowManager : public ApplicationDelegate,
-                      public DebugPanel::Delegate,
-                      public ViewManagerDelegate,
-                      public ViewEventDispatcher {
+class WindowManager
+    : public ApplicationDelegate,
+      public DebugPanel::Delegate,
+      public ViewManagerDelegate,
+      public ViewEventDispatcher,
+      public InterfaceFactoryWithContext<WindowManagerConnection,
+                                         WindowManager>,
+      public InterfaceFactoryWithContext<NavigatorHost, WindowManager> {
  public:
   WindowManager()
-      : launcher_ui_(NULL),
+      : InterfaceFactoryWithContext<WindowManagerConnection, WindowManager>(
+            this),
+        InterfaceFactoryWithContext<NavigatorHost, WindowManager>(this),
+        launcher_ui_(NULL),
         view_manager_(NULL),
-        app_(NULL) {
-  }
+        view_manager_client_factory_(this),
+        app_(NULL) {}
 
   virtual ~WindowManager() {}
 
   void CloseWindow(Id node_id) {
     Node* node = view_manager_->GetNodeById(node_id);
     DCHECK(node);
     std::vector<Node*>::iterator iter =
         std::find(windows_.begin(), windows_.end(), node);
     DCHECK(iter != windows_.end());
     windows_.erase(iter);
@@ skipping 50 matching lines @@
  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<WindowManagerConnection>(this);
-    connection->AddService<NavigatorHost>(this);
-    ViewManager::ConfigureIncomingConnection(connection, this);
+    connection->AddService<IWindowManager>(this);
+    connection->AddService<navigation::NavigatorHost>(this);
+    connection->AddService(&view_manager_client_factory_);
     return true;
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnRootAdded(ViewManager* view_manager, Node* root) OVERRIDE {
     DCHECK(!view_manager_);
     view_manager_ = view_manager;
     view_manager_->SetEventDispatcher(this);
 
     Node* node = Node::Create(view_manager_);
@@ skipping 148 matching lines @@
     debug_panel_ = new DebugPanel(this, node);
     return node->id();
   }
 
   scoped_ptr<ViewsInit> views_init_;
   DebugPanel* debug_panel_;
   launcher::LauncherPtr launcher_;
   Node* launcher_ui_;
   std::vector<Node*> windows_;
   ViewManager* view_manager_;
+  ViewManagerClientFactory view_manager_client_factory_;
   scoped_ptr<RootLayoutManager> root_layout_manager_;
 
   // Id of the node most content is added to. The keyboard is NOT added here.
   Id content_node_id_;
 
   scoped_ptr<KeyboardManager> keyboard_manager_;
   ApplicationImpl* app_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManager);
 };
@@ skipping 23 matching lines @@
 }
 
 }  // namespace examples
 
 // static
 ApplicationDelegate* ApplicationDelegate::Create() {
   return new examples::WindowManager;
 }
 
 }  // namespace mojo