code review 4607052: os.Error API: don't export os.ErrorString, use os.NewEr...

src/pkg/netchan/import.go

 // Copyright 2010 The Go 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 netchan
 
 import (
         "io"
         "log"
         "net"
@@ skipping 84 matching lines @@
                 case payData:
                         // done lower in loop
                 case payError:
                         if e := imp.decode(errValue); e != nil {
                                 impLog("error:", e)
                                 return
                         }
                         if err.Error != "" {
                                 impLog("response error:", err.Error)
                                 select {
-                                case imp.errors <- os.ErrorString(err.Error):
+                                case imp.errors <- os.NewError(err.Error):
                                         continue // errors are not acknowledged
                                 default:
                                         imp.shutdown()
                                         return
                                 }
                         }
                 case payClosed:
                         nch := imp.getChan(hdr.Id, false)
                         if nch != nil {
                                 nch.close()
@@ skipping 80 matching lines @@
 //      fmt.Printf("%+v\n", <-ch)
 func (imp *Importer) ImportNValues(name string, chT interface{}, dir Dir, size, n int) os.Error {
         ch, err := checkChan(chT, dir)
         if err != nil {
                 return err
         }
         imp.chanLock.Lock()
         defer imp.chanLock.Unlock()
         _, present := imp.names[name]
         if present {
-                return os.ErrorString("channel name already being imported:" + name)
+                return os.NewError("channel name already being imported:" + name)
         }
         if size < 1 {
                 size = 1
         }
         id := imp.maxId
         imp.maxId++
         nch := newNetChan(name, id, &chanDir{ch, dir}, imp.encDec, size, int64(n))
         imp.names[name] = nch
         imp.chans[id] = nch
         // Tell the other side about this channel.
@@ skipping 30 matching lines @@
         return nil
 }
 
 // Hangup disassociates the named channel from the Importer and closes
 // the channel.  Messages in flight for the channel may be dropped.
 func (imp *Importer) Hangup(name string) os.Error {
         imp.chanLock.Lock()
         defer imp.chanLock.Unlock()
         nc := imp.names[name]
         if nc == nil {
-                return os.ErrorString("netchan import: hangup: no such channel: " + name)
+                return os.NewError("netchan import: hangup: no such channel: " + name)
         }
         imp.names[name] = nil, false
         imp.chans[nc.id] = nil, false
         nc.close()
         return nil
 }
 
 func (imp *Importer) unackedCount() int64 {
         imp.mu.Lock()
         n := imp.unacked
         imp.mu.Unlock()
         return n
 }
 
 // Drain waits until all messages sent from this exporter/importer, including
 // those not yet sent to any server and possibly including those sent while
 // Drain was executing, have been received by the exporter.  In short, it
 // waits until all the importer's messages have been received.
 // If the timeout (measured in nanoseconds) is positive and Drain takes
 // longer than that to complete, an error is returned.
 func (imp *Importer) Drain(timeout int64) os.Error {
         startTime := time.Nanoseconds()
         for imp.unackedCount() > 0 {
                 if timeout > 0 && time.Nanoseconds()-startTime >= timeout {
-                        return os.ErrorString("timeout")
+                        return os.NewError("timeout")
                 }
                 time.Sleep(100 * 1e6)
         }
         return nil
 }