Provide an API to the example window manager app that supports closing a window.

mojo/services/public/cpp/view_manager/tests/view_manager_unittest.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/public/cpp/view_manager/view_manager.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/public/cpp/application/application.h"
@@ skipping 34 matching lines @@
 
 void WaitForAllChangesToBeAcked(ViewManager* manager) {
   ViewManagerPrivate(manager).synchronizer()->set_changes_acked_callback(
       base::Bind(&QuitRunLoopOnChangesAcked));
   DoRunLoop();
   ViewManagerPrivate(manager).synchronizer()->ClearChangesAckedCallback();
 }
 
 class ConnectServiceLoader : public ServiceLoader {
  public:
-  explicit ConnectServiceLoader(base::Callback<void(ViewManager*)> callback)
+  explicit ConnectServiceLoader(const ViewManager::RootCallback& callback)
       : callback_(callback) {}
   virtual ~ConnectServiceLoader() {}
 
  private:
   // Overridden from ServiceLoader:
   virtual void LoadService(ServiceManager* manager,
                            const GURL& url,
                            ScopedMessagePipeHandle shell_handle) OVERRIDE {
     scoped_ptr<Application> app(new Application(shell_handle.Pass()));
-    ViewManager::Create(app.get(), callback_);
+    // TODO(beng): test removed callback.
+    ViewManager::Create(app.get(), callback_, ViewManager::RootCallback());
     apps_.push_back(app.release());
   }
   virtual void OnServiceError(ServiceManager* manager,
                               const GURL& url) OVERRIDE {
   }
 
   ScopedVector<Application> apps_;
-  base::Callback<void(ViewManager*)> callback_;
+  ViewManager::RootCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectServiceLoader);
 };
 
 class ActiveViewChangedObserver : public ViewTreeNodeObserver {
  public:
   explicit ActiveViewChangedObserver(ViewTreeNode* node)
       : node_(node) {}
   virtual ~ActiveViewChangedObserver() {}
 
@@ skipping 236 matching lines @@
     return view_manager;
   }
 
   void UnloadApplication(const GURL& url) {
     test_helper_.SetLoaderForURL(scoped_ptr<ServiceLoader>(), url);
   }
 
  private:
   // Overridden from testing::Test:
   virtual void SetUp() OVERRIDE {
-    base::Callback<void(ViewManager*)> ready_callback =
+    ViewManager::RootCallback ready_callback =
         base::Bind(&ViewManagerTest::OnViewManagerLoaded,
                    base::Unretained(this));
     test_helper_.Init();
     test_helper_.SetLoaderForURL(
         scoped_ptr<ServiceLoader>(new ConnectServiceLoader(ready_callback)),
         GURL(kWindowManagerURL));
     test_helper_.SetLoaderForURL(
         scoped_ptr<ServiceLoader>(new ConnectServiceLoader(ready_callback)),
         GURL(kEmbeddedApp1URL));
 
@@ skipping 14 matching lines @@
     bool result = false;
     view_manager_init->Connect(
         url,
         base::Bind(&ViewManagerTest::ViewManagerInitConnectCallback,
                    base::Unretained(this), &result));
     RunRunLoop();
     window_manager_ = GetLoadedViewManager();
     return result;
   }
 
-  void OnViewManagerLoaded(ViewManager* view_manager) {
+  void OnViewManagerLoaded(ViewManager* view_manager, ViewTreeNode* root) {
     loaded_view_manager_ = view_manager;
     connect_loop_->Quit();
   }
 
   void RunRunLoop() {
     base::RunLoop run_loop;
     connect_loop_ = &run_loop;
     connect_loop_->Run();
     connect_loop_ = NULL;
   }
@@ skipping 315 matching lines @@
   window_manager()->roots().front()->AddChild(node1);
   ViewTreeNode* node2 = ViewTreeNode::Create(window_manager());
   window_manager()->roots().front()->AddChild(node2);
   ViewManager* embedded1 = Embed(window_manager(), node1);
   ViewManager* embedded2 = Embed(window_manager(), node2);
   EXPECT_EQ(embedded1, embedded2);
 }
 
 }  // namespace view_manager
 }  // namespace mojo