Nesting

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 32 matching lines @@
   QuitRunLoop();
 }
 
 void WaitForAllChangesToBeAcked(ViewManager* manager) {
   ViewManagerPrivate(manager).synchronizer()->set_changes_acked_callback(
       base::Bind(&QuitRunLoopOnChangesAcked));
   DoRunLoop();
   ViewManagerPrivate(manager).synchronizer()->ClearChangesAckedCallback();
 }
 
-class ConnectServiceLoader : public ServiceLoader {
+class ConnectServiceLoader : public ServiceLoader,
+                             public ViewManagerDelegate {
  public:
-  explicit ConnectServiceLoader(const ViewManager::RootCallback& callback)
-      : callback_(callback) {}
+  typedef base::Callback<void(ViewManager*, ViewTreeNode*)> LoadedCallback;
+
+  explicit ConnectServiceLoader(const LoadedCallback& 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()));
-    // TODO(beng): test removed callback.
-    ViewManager::Create(app.get(), callback_, ViewManager::RootCallback());
+    ViewManager::Create(app.get(), this);
     apps_.push_back(app.release());
   }
   virtual void OnServiceError(ServiceManager* manager,
                               const GURL& url) OVERRIDE {
   }
 
+  // Overridden from ViewManagerDelegate:
+  virtual void OnRootAdded(ViewManager* view_manager,
+                           ViewTreeNode* root) OVERRIDE {
+    callback_.Run(view_manager, root);
+  }
+
   ScopedVector<Application> apps_;
-  ViewManager::RootCallback callback_;
+  LoadedCallback 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 {
-    ViewManager::RootCallback ready_callback =
+    ConnectServiceLoader::LoadedCallback 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 350 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