ApplicationConnection lifetime management changes.

mandoline/ui/browser/browser_apptest.cc

 // Copyright 2015 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 "mandoline/ui/browser/browser.h"
 
 #include "base/run_loop.h"
 #include "components/view_manager/public/cpp/view.h"
 #include "mandoline/ui/browser/browser_delegate.h"
 #include "mojo/application/public/cpp/application_connection.h"
@@ skipping 34 matching lines @@
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(TestBrowser);
 };
 
 class BrowserTest : public mojo::test::ApplicationTestBase,
                     public mojo::ApplicationDelegate,
                     public BrowserDelegate {
  public:
   BrowserTest()
       : app_(nullptr),
-        last_closed_connection_(nullptr),
         last_browser_closed_(nullptr) {}
 
   // Creates a new Browser object.
   TestBrowser* CreateBrowser() {
     if (!app_)
       return nullptr;
     TestBrowser* browser = new TestBrowser(app_, this);
     browsers_.insert(browser);
     return browser;
   }
 
   TestBrowser* WaitForBrowserClosed() {
     if (!last_browser_closed_) {
       browser_closed_run_loop_.reset(new base::RunLoop);
       browser_closed_run_loop_->Run();
       browser_closed_run_loop_.reset();
     }
     TestBrowser* last_browser = last_browser_closed_;
     last_browser_closed_ = nullptr;
     return last_browser;
   }
 
-  // Returns the last ApplicationConnection closed.
-  void* last_closed_connection() {
-    return last_closed_connection_;
-  }
-
   // Overridden from ApplicationDelegate:
   void Initialize(mojo::ApplicationImpl* app) override {
     app_ = app;
   }
 
-  void OnWillCloseConnection(mojo::ApplicationConnection* connection) override {
-    // WARNING: DO NOT FOLLOW THIS POINTER. IT WILL BE DESTROYED.
-    last_closed_connection_ = connection;
-  }
-
   // ApplicationTestBase:
   ApplicationDelegate* GetApplicationDelegate() override { return this; }
 
   // Overridden from BrowserDelegate:
   void BrowserClosed(Browser* browser) override {
     scoped_ptr<Browser> browser_owner(browser);
     TestBrowser* test_browser = static_cast<TestBrowser*>(browser);
     DCHECK_GT(browsers_.count(test_browser), 0u);
     browsers_.erase(test_browser);
     last_browser_closed_ = test_browser;
     if (browser_closed_run_loop_) {
       browser_owner.reset();
       browser_closed_run_loop_->Quit();
     }
   }
 
   void InitUIIfNecessary(Browser* browser, mojo::View* root_view) override {}
 
  private:
   mojo::ApplicationImpl* app_;
-  void* last_closed_connection_;
   std::set<TestBrowser*> browsers_;
   TestBrowser* last_browser_closed_;
   scoped_ptr<base::RunLoop> browser_closed_run_loop_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(BrowserTest);
 };
 
 // This test verifies that closing a Browser closes the associated application
 // connection with the view manager.
 TEST_F(BrowserTest, ClosingBrowserClosesAppConnection) {
   Browser* browser = CreateBrowser();
   ASSERT_NE(nullptr, browser);
   mojo::ApplicationConnection* view_manager_connection =
       browser->view_manager_init_.connection();
+  mojo::ApplicationConnection::TestApi connection_test_api(
+      view_manager_connection);
   ASSERT_NE(nullptr, view_manager_connection);
+  base::WeakPtr<mojo::ApplicationConnection> ptr =
+      connection_test_api.GetWeakPtr();
   BrowserClosed(browser);
-  EXPECT_EQ(last_closed_connection(), view_manager_connection);
+  EXPECT_FALSE(ptr);
 }
 
 // This test verifies that we can create two Browsers and each Browser has a
 // different AppliationConnection and different root view.
 TEST_F(BrowserTest, TwoBrowsers) {
   TestBrowser* browser1 = CreateBrowser();
   mojo::ApplicationConnection* browser1_connection =
       browser1->view_manager_init_.connection();
   ASSERT_NE(nullptr, browser1);
   browser1->WaitForOnEmbed();
@@ skipping 12 matching lines @@
 
   // Deleting the view manager closes the connection.
   delete browser1->root()->view_manager();
   EXPECT_EQ(browser1, WaitForBrowserClosed());
 
   delete browser2->root()->view_manager();
   EXPECT_EQ(browser2, WaitForBrowserClosed());
 }
 
 }  // namespace mandoline