Update mojo sdk to rev c02a28868825edfa57ab77947b8cb15e741c5598

extensions/browser/mojo/stash_backend_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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "extensions/browser/mojo/stash_backend.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 15 matching lines @@
   uint32_t num_bytes = 1;
   result = mojo::WriteDataRaw(producer_handle.get(), "a", &num_bytes,
                               MOJO_WRITE_DATA_FLAG_NONE);
   EXPECT_EQ(MOJO_RESULT_OK, result);
   EXPECT_EQ(1u, num_bytes);
   return mojo::ScopedHandle::From(consumer_handle.Pass());
 }
 
 }  // namespace
 
-class StashServiceTest : public testing::Test, public mojo::ErrorHandler {
+class StashServiceTest : public testing::Test {
  public:
   enum Event {
     EVENT_NONE,
     EVENT_STASH_RETRIEVED,
     EVENT_HANDLE_READY,
   };
 
   StashServiceTest() {}
 
   void SetUp() override {
     expecting_error_ = false;
     expected_event_ = EVENT_NONE;
     stash_backend_.reset(new StashBackend(base::Bind(
         &StashServiceTest::OnHandleReadyToRead, base::Unretained(this))));
     stash_backend_->BindToRequest(mojo::GetProxy(&stash_service_));
-    stash_service_.set_error_handler(this);
+    stash_service_.set_connection_error_handler(base::Bind(&OnConnectionError));
     handles_ready_ = 0;
   }
 
-  void OnConnectionError() override { FAIL() << "Unexpected connection error"; }
+  static void OnConnectionError() { FAIL() << "Unexpected connection error"; }
 
   mojo::Array<StashedObjectPtr> RetrieveStash() {
     mojo::Array<StashedObjectPtr> stash;
     stash_service_->RetrieveStash(base::Bind(
         &StashServiceTest::StashRetrieved, base::Unretained(this), &stash));
     WaitForEvent(EVENT_STASH_RETRIEVED);
     return stash.Pass();
   }
 
   void StashRetrieved(mojo::Array<StashedObjectPtr>* output,
@@ skipping 197 matching lines @@
 
   stash_service_->AddToStash(RetrieveStash());
   WaitForEvent(EVENT_HANDLE_READY);
   EXPECT_EQ(2, handles_ready_);
 }
 
 // Test that a stash service discards stashed objects when the backend no longer
 // exists.
 TEST_F(StashServiceTest, ServiceWithDeletedBackend) {
   stash_backend_.reset();
-  stash_service_.set_error_handler(this);
+  stash_service_.set_connection_error_handler(base::Bind(&OnConnectionError));
 
   mojo::Array<StashedObjectPtr> stashed_objects;
   StashedObjectPtr stashed_object(StashedObject::New());
   stashed_object->id = "test type";
   stashed_object->data.push_back(1);
   mojo::MessagePipe message_pipe;
   stashed_object->stashed_handles.push_back(
       mojo::ScopedHandle::From(message_pipe.handle0.Pass()));
   stashed_objects.push_back(stashed_object.Pass());
   stash_service_->AddToStash(stashed_objects.Pass());
   stashed_objects = RetrieveStash();
   ASSERT_EQ(0u, stashed_objects.size());
   // Check that the stashed handle has been closed.
   MojoResult result =
       mojo::Wait(message_pipe.handle1.get(),
                  MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_READABLE,
                  MOJO_DEADLINE_INDEFINITE, nullptr);
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
 }
 
 }  // namespace extensions