Update dependencies

Among others, this updates minio-go, so that the new "eu-west-3" zone
for AWS is supported.

vendor/cloud.google.com/go/pubsub/topic.go

@@ -24,9 +24,12 @@ import (
 
 	"cloud.google.com/go/iam"
 	"github.com/golang/protobuf/proto"
+	gax "github.com/googleapis/gax-go"
 	"golang.org/x/net/context"
 	"google.golang.org/api/support/bundler"
 	pb "google.golang.org/genproto/googleapis/pubsub/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
 )
 
 const (
@@ -47,7 +50,7 @@ var ErrOversizedMessage = bundler.ErrOversizedItem
 //
 // The methods of Topic are safe for use by multiple goroutines.
 type Topic struct {
-	s service
+	c *Client
 	// The fully qualified identifier for the topic, in the format "projects/<projid>/topics/<name>"
 	name string
 
@@ -102,8 +105,11 @@ var DefaultPublishSettings = PublishSettings{
 // If the topic already exists an error will be returned.
 func (c *Client) CreateTopic(ctx context.Context, id string) (*Topic, error) {
 	t := c.Topic(id)
-	err := c.s.createTopic(ctx, t.name)
-	return t, err
+	_, err := c.pubc.CreateTopic(ctx, &pb.Topic{Name: t.name})
+	if err != nil {
+		return nil, err
+	}
+	return t, nil
 }
 
 // Topic creates a reference to a topic in the client's project.
@@ -123,15 +129,15 @@ func (c *Client) Topic(id string) *Topic {
 //
 // Avoid creating many Topic instances if you use them to publish.
 func (c *Client) TopicInProject(id, projectID string) *Topic {
-	return newTopic(c.s, fmt.Sprintf("projects/%s/topics/%s", projectID, id))
+	return newTopic(c, fmt.Sprintf("projects/%s/topics/%s", projectID, id))
 }
 
-func newTopic(s service, name string) *Topic {
+func newTopic(c *Client, name string) *Topic {
 	// bundlec is unbuffered. A buffer would occupy memory not
 	// accounted for by the bundler, so BufferedByteLimit would be a lie:
 	// the actual memory consumed would be higher.
 	return &Topic{
-		s:               s,
+		c:               c,
 		name:            name,
 		PublishSettings: DefaultPublishSettings,
 		bundlec:         make(chan []*bundledMessage),
@@ -140,16 +146,23 @@ func newTopic(s service, name string) *Topic {
 
 // Topics returns an iterator which returns all of the topics for the client's project.
 func (c *Client) Topics(ctx context.Context) *TopicIterator {
+	it := c.pubc.ListTopics(ctx, &pb.ListTopicsRequest{Project: c.fullyQualifiedProjectName()})
 	return &TopicIterator{
-		s:    c.s,
-		next: c.s.listProjectTopics(ctx, c.fullyQualifiedProjectName()),
+		c: c,
+		next: func() (string, error) {
+			topic, err := it.Next()
+			if err != nil {
+				return "", err
+			}
+			return topic.Name, nil
+		},
 	}
 }
 
 // TopicIterator is an iterator that returns a series of topics.
 type TopicIterator struct {
-	s    service
-	next nextStringFunc
+	c    *Client
+	next func() (string, error)
 }
 
 // Next returns the next topic. If there are no more topics, iterator.Done will be returned.
@@ -158,7 +171,7 @@ func (tps *TopicIterator) Next() (*Topic, error) {
 	if err != nil {
 		return nil, err
 	}
-	return newTopic(tps.s, topicName), nil
+	return newTopic(tps.c, topicName), nil
 }
 
 // ID returns the unique idenfier of the topic within its project.
@@ -178,7 +191,7 @@ func (t *Topic) String() string {
 
 // Delete deletes the topic.
 func (t *Topic) Delete(ctx context.Context) error {
-	return t.s.deleteTopic(ctx, t.name)
+	return t.c.pubc.DeleteTopic(ctx, &pb.DeleteTopicRequest{Topic: t.name})
 }
 
 // Exists reports whether the topic exists on the server.
@@ -186,21 +199,30 @@ func (t *Topic) Exists(ctx context.Context) (bool, error) {
 	if t.name == "_deleted-topic_" {
 		return false, nil
 	}
-
-	return t.s.topicExists(ctx, t.name)
+	_, err := t.c.pubc.GetTopic(ctx, &pb.GetTopicRequest{Topic: t.name})
+	if err == nil {
+		return true, nil
+	}
+	if grpc.Code(err) == codes.NotFound {
+		return false, nil
+	}
+	return false, err
 }
 
 func (t *Topic) IAM() *iam.Handle {
-	return t.s.iamHandle(t.name)
+	return iam.InternalNewHandle(t.c.pubc.Connection(), t.name)
 }
 
 // Subscriptions returns an iterator which returns the subscriptions for this topic.
+//
+// Some of the returned subscriptions may belong to a project other than t.
 func (t *Topic) Subscriptions(ctx context.Context) *SubscriptionIterator {
-	// NOTE: zero or more Subscriptions that are ultimately returned by this
-	// Subscriptions iterator may belong to a different project to t.
+	it := t.c.pubc.ListTopicSubscriptions(ctx, &pb.ListTopicSubscriptionsRequest{
+		Topic: t.name,
+	})
 	return &SubscriptionIterator{
-		s:    t.s,
-		next: t.s.listTopicSubscriptions(ctx, t.name),
+		c:    t.c,
+		next: it.Next,
 	}
 }
 
@@ -353,16 +375,23 @@ func (t *Topic) initBundler() {
 }
 
 func (t *Topic) publishMessageBundle(ctx context.Context, bms []*bundledMessage) {
-	msgs := make([]*Message, len(bms))
+	pbMsgs := make([]*pb.PubsubMessage, len(bms))
 	for i, bm := range bms {
-		msgs[i], bm.msg = bm.msg, nil // release bm.msg for GC
+		pbMsgs[i] = &pb.PubsubMessage{
+			Data:       bm.msg.Data,
+			Attributes: bm.msg.Attributes,
+		}
+		bm.msg = nil // release bm.msg for GC
 	}
-	ids, err := t.s.publishMessages(ctx, t.name, msgs)
+	res, err := t.c.pubc.Publish(ctx, &pb.PublishRequest{
+		Topic:    t.name,
+		Messages: pbMsgs,
+	}, gax.WithGRPCOptions(grpc.MaxCallSendMsgSize(maxSendRecvBytes)))
 	for i, bm := range bms {
 		if err != nil {
 			bm.res.set("", err)
 		} else {
-			bm.res.set(ids[i], nil)
+			bm.res.set(res.MessageIds[i], nil)
 		}
 	}
 }