Update mojo sdk to rev 7214b7ec7d27563b2666afad86cf1c5895c56c18

third_party/mojo/src/mojo/public/go/bindings/async_waiter.go

 // 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.
 
 package bindings
 
 import (
         "fmt"
+        "runtime"
         "sync"
         "sync/atomic"
 
         "mojo/public/go/system"
 )
 
 var defaultWaiter *asyncWaiterImpl
 var once sync.Once
 
 // GetAsyncWaiter returns a default implementation of |AsyncWaiter| interface.
@@ skipping 60 matching lines @@
         signals      []system.MojoHandleSignals
         asyncWaitIds []AsyncWaitId
         responses    []chan<- WaitResponse
 
         // Flag shared between waiterImpl and worker that is 1 iff the worker is
         // already notified by waiterImpl. The worker sets it to 0 as soon as
         // |WaitMany()| succeeds.
         isNotified *int32
         waitChan   <-chan waitRequest // should have a non-empty buffer
         cancelChan <-chan AsyncWaitId // should have a non-empty buffer
-        ids        Counter            // is incremented each |AsyncWait()| call
+        ids        uint64             // is incremented each |AsyncWait()| call
 }
 
 // removeHandle removes handle at provided index without sending response by
 // swapping all information associated with index-th handle with the last one
 // and removing the last one.
 func (w *asyncWaiterWorker) removeHandle(index int) {
         l := len(w.handles) - 1
         // Swap with the last and remove last.
         w.handles[index] = w.handles[l]
         w.handles = w.handles[0:l]
@@ skipping 36 matching lines @@
 // processIncomingRequests processes all queued async wait or cancel requests
 // sent by asyncWaiterImpl.
 func (w *asyncWaiterWorker) processIncomingRequests() {
         for {
                 select {
                 case request := <-w.waitChan:
                         w.handles = append(w.handles, request.handle)
                         w.signals = append(w.signals, request.signals)
                         w.responses = append(w.responses, request.responseChan)
 
-                        id := AsyncWaitId(w.ids.Next())
+                        w.ids++
+                        id := AsyncWaitId(w.ids)
                         w.asyncWaitIds = append(w.asyncWaitIds, id)
                         request.idChan <- id
                 case AsyncWaitId := <-w.cancelChan:
                         // Zero index is reserved for the waking message pipe handle.
                         index := 0
                         for i := 1; i < len(w.asyncWaitIds); i++ {
                                 if w.asyncWaitIds[i] == AsyncWaitId {
                                         index = i
                                         break
                                 }
@@ skipping 47 matching lines @@
         wakingHandle system.MessagePipeHandle
 
         // Flag shared between waiterImpl and worker that is 1 iff the worker is
         // already notified by waiterImpl. The worker sets it to 0 as soon as
         // |WaitMany()| succeeds.
         isWorkerNotified *int32
         waitChan         chan<- waitRequest // should have a non-empty buffer
         cancelChan       chan<- AsyncWaitId // should have a non-empty buffer
 }
 
+func finalizeWorker(worker *asyncWaiterWorker) {
+        // Close waking handle on worker side.
+        worker.handles[0].Close()
+}
+
+func finalizeAsyncWaiter(waiter *asyncWaiterImpl) {
+        waiter.wakingHandle.Close()
+}
+
 // newAsyncWaiter creates an asyncWaiterImpl and starts its worker goroutine.
 func newAsyncWaiter() *asyncWaiterImpl {
         result, h0, h1 := system.GetCore().CreateMessagePipe(nil)
         if result != system.MOJO_RESULT_OK {
                 panic(fmt.Sprintf("can't create message pipe %v", result))
         }
         waitChan := make(chan waitRequest, 10)
         cancelChan := make(chan AsyncWaitId, 10)
         isNotified := new(int32)
-        worker := asyncWaiterWorker{
+        worker := &asyncWaiterWorker{
                 []system.Handle{h1},
                 []system.MojoHandleSignals{system.MOJO_HANDLE_SIGNAL_READABLE},
                 []AsyncWaitId{0},
                 []chan<- WaitResponse{make(chan WaitResponse)},
                 isNotified,
                 waitChan,
                 cancelChan,
-                Counter{},
+                0,
         }
+        runtime.SetFinalizer(worker, finalizeWorker)
         go worker.runLoop()
-        return &asyncWaiterImpl{
+        waiter := &asyncWaiterImpl{
                 wakingHandle:     h0,
                 isWorkerNotified: isNotified,
                 waitChan:         waitChan,
                 cancelChan:       cancelChan,
         }
+        runtime.SetFinalizer(waiter, finalizeAsyncWaiter)
+        return waiter
 }
 
 // wakeWorker wakes the worker from |WaitMany()| call. This should be called
 // after sending a message to |waitChan| or |cancelChan| to avoid deadlock.
 func (w *asyncWaiterImpl) wakeWorker() {
         if atomic.CompareAndSwapInt32(w.isWorkerNotified, 0, 1) {
                 result := w.wakingHandle.WriteMessage([]byte{0}, nil, system.MOJO_WRITE_MESSAGE_FLAG_NONE)
                 if result != system.MOJO_RESULT_OK {
                         panic("can't write to a message pipe")
                 }
         }
 }
 
 func (w *asyncWaiterImpl) AsyncWait(handle system.Handle, signals system.MojoHandleSignals, responseChan chan<- WaitResponse) AsyncWaitId {
         idChan := make(chan AsyncWaitId, 1)
         w.waitChan <- waitRequest{
                 handle,
                 signals,
                 idChan,
                 responseChan,
         }
         w.wakeWorker()
         return <-idChan
 }
 
 func (w *asyncWaiterImpl) CancelWait(id AsyncWaitId) {
         w.cancelChan <- id
         w.wakeWorker()
 }