Fixed the build, broken by jacobsa/gcloud@8d2a8fb.

fs/caching_test.go

@@ -171,7 +171,10 @@ func (t *CachingTest) DirectoryRemovedRemotely() {
 	AssertEq(nil, err)
 
 	// Remove the backing object in GCS.
-	err = t.uncachedBucket.DeleteObject(t.ctx, name+"/")
+	err = t.uncachedBucket.DeleteObject(
+		t.ctx,
+		&gcs.DeleteObjectRequest{Name: name + "/"})
+
 	AssertEq(nil, err)
 
 	// Because we are caching, the directory should still appear to exist.
@@ -259,7 +262,10 @@ func (t *CachingTest) TypeOfNameChanges_RemoteModifier() {
 
 	// Remove the backing object in GCS, updating the bucket cache (but not the
 	// file system type cache)
-	err = t.bucket.DeleteObject(t.ctx, name+"/")
+	err = t.bucket.DeleteObject(
+		t.ctx,
+		&gcs.DeleteObjectRequest{Name: name + "/"})
+
 	AssertEq(nil, err)
 
 	// Create a file with the same name via GCS, again updating the bucket cache.

fs/foreign_modifications_test.go

@@ -685,7 +685,11 @@ func (t *ForeignModsTest) ObjectIsDeleted_File() {
 	AssertEq(nil, err)
 
 	// Delete the object.
-	AssertEq(nil, t.bucket.DeleteObject(t.ctx, "foo"))
+	AssertEq(
+		nil,
+		t.bucket.DeleteObject(
+			t.ctx,
+			&gcs.DeleteObjectRequest{Name: "foo"}))
 
 	// The file should appear to be unlinked, but with the previous contents.
 	fi, err := f1.Stat()
@@ -717,7 +721,11 @@ func (t *ForeignModsTest) ObjectIsDeleted_Directory() {
 	AssertEq(nil, err)
 
 	// Delete the object.
-	AssertEq(nil, t.bucket.DeleteObject(t.ctx, "dir/"))
+	AssertEq(
+		nil,
+		t.bucket.DeleteObject(
+			t.ctx,
+			&gcs.DeleteObjectRequest{Name: "dir/"}))
 
 	// The inode should still be fstat'able.
 	fi, err := t.f1.Stat()

fs/garbage_collect.go

@@ -72,7 +72,12 @@ func garbageCollectOnce(
 	// Delete those objects.
 	b.Add(func(ctx context.Context) (err error) {
 		for name := range staleNames {
-			err = bucket.DeleteObject(ctx, name)
+			err = bucket.DeleteObject(
+				ctx,
+				&gcs.DeleteObjectRequest{
+					Name: name,
+				})
+
 			if err != nil {
 				err = fmt.Errorf("DeleteObject(%q): %v", name, err)
 				return

fs/implicit_dirs_test.go

@@ -24,6 +24,7 @@ import (
 	"syscall"
 
 	"github.com/jacobsa/fuse/fusetesting"
+	"github.com/jacobsa/gcloud/gcs"
 	. "github.com/jacobsa/oglematchers"
 	. "github.com/jacobsa/ogletest"
 )
@@ -439,7 +440,11 @@ func (t *ImplicitDirsTest) ExplicitBecomesImplicit() {
 	ExpectTrue(fi.IsDir())
 
 	// Remove the explicit placeholder.
-	AssertEq(nil, t.bucket.DeleteObject(t.ctx, "foo/"))
+	AssertEq(
+		nil,
+		t.bucket.DeleteObject(
+			t.ctx,
+			&gcs.DeleteObjectRequest{Name: "foo/"}))
 
 	// Stat the directory again.
 	fi, err = os.Stat(path.Join(t.mfs.Dir(), "foo"))

fs/inode/dir.go

@@ -785,7 +785,12 @@ func (d *dirInode) DeleteChildFile(
 	name string) (err error) {
 	d.cache.Erase(name)
 
-	err = d.bucket.DeleteObject(ctx, path.Join(d.Name(), name))
+	err = d.bucket.DeleteObject(
+		ctx,
+		&gcs.DeleteObjectRequest{
+			Name: path.Join(d.Name(), name),
+		})
+
 	if err != nil {
 		err = fmt.Errorf("DeleteObject: %v", err)
 		return
@@ -802,7 +807,12 @@ func (d *dirInode) DeleteChildDir(
 
 	// Delete the backing object. Unfortunately we have no way to precondition
 	// this on the directory being empty.
-	err = d.bucket.DeleteObject(ctx, path.Join(d.Name(), name)+"/")
+	err = d.bucket.DeleteObject(
+		ctx,
+		&gcs.DeleteObjectRequest{
+			Name: path.Join(d.Name(), name) + "/",
+		})
+
 	if err != nil {
 		err = fmt.Errorf("DeleteObject: %v", err)
 		return

fs/local_modifications_test.go

@@ -1609,7 +1609,12 @@ func (t *FileTest) UnlinkFile_NoLongerInBucket() {
 	AssertEq(nil, err)
 
 	// Delete it from the bucket through the back door.
-	err = t.bucket.DeleteObject(t.ctx, "foo")
+	AssertEq(
+		nil,
+		t.bucket.DeleteObject(
+			t.ctx,
+			&gcs.DeleteObjectRequest{Name: "foo"}))
+
 	AssertEq(nil, err)
 
 	// Attempt to unlink it.

gcsproxy/append_object_creator.go

@@ -114,7 +114,12 @@ func (oc *appendObjectCreator) Create(
 
 	// Attempt to delete the temporary object when we're done.
 	defer func() {
-		deleteErr := oc.bucket.DeleteObject(ctx, tmp.Name)
+		deleteErr := oc.bucket.DeleteObject(
+			ctx,
+			&gcs.DeleteObjectRequest{
+				Name: tmp.Name,
+			})
+
 		if err == nil && deleteErr != nil {
 			err = fmt.Errorf("DeleteObject: %v", deleteErr)
 		}

gcsproxy/append_object_creator_test.go

@@ -16,6 +16,7 @@ package gcsproxy
 
 import (
 	"errors"
+	"fmt"
 	"io/ioutil"
 	"strings"
 	"testing"
@@ -30,6 +31,31 @@ import (
 
 func TestAppendObjectCreator(t *testing.T) { RunTests(t) }
 
+////////////////////////////////////////////////////////////////////////
+// Helpers
+////////////////////////////////////////////////////////////////////////
+
+func deleteReqName(expected string) (m Matcher) {
+	m = NewMatcher(
+		func(c interface{}) (err error) {
+			req, ok := c.(*gcs.DeleteObjectRequest)
+			if !ok {
+				err = fmt.Errorf("which has type %T", c)
+				return
+			}
+
+			if req.Name != expected {
+				err = fmt.Errorf("which is for name %q", req.Name)
+				return
+			}
+
+			return
+		},
+		fmt.Sprintf("Delete request for name %q", expected))
+
+	return
+}
+
 ////////////////////////////////////////////////////////////////////////
 // Boilerplate
 ////////////////////////////////////////////////////////////////////////
@@ -140,7 +166,7 @@ func (t *AppendObjectCreatorTest) CallsComposeObjects() {
 		WillOnce(DoAll(SaveArg(1, &req), Return(nil, errors.New(""))))
 
 	// DeleteObject
-	ExpectCall(t.bucket, "DeleteObject")(Any(), tmpObject.Name).
+	ExpectCall(t.bucket, "DeleteObject")(Any(), deleteReqName(tmpObject.Name)).
 		WillOnce(Return(nil))
 
 	// Call
@@ -178,7 +204,7 @@ func (t *AppendObjectCreatorTest) ComposeObjectsFails() {
 		WillOnce(Return(nil, errors.New("taco")))
 
 	// DeleteObject
-	ExpectCall(t.bucket, "DeleteObject")(Any(), tmpObject.Name).
+	ExpectCall(t.bucket, "DeleteObject")(Any(), deleteReqName(tmpObject.Name)).
 		WillOnce(Return(errors.New("")))
 
 	// Call
@@ -202,7 +228,7 @@ func (t *AppendObjectCreatorTest) ComposeObjectsReturnsPreconditionError() {
 		WillOnce(Return(nil, &gcs.PreconditionError{Err: errors.New("taco")}))
 
 	// DeleteObject
-	ExpectCall(t.bucket, "DeleteObject")(Any(), tmpObject.Name).
+	ExpectCall(t.bucket, "DeleteObject")(Any(), deleteReqName(tmpObject.Name)).
 		WillOnce(Return(errors.New("")))
 
 	// Call
@@ -227,7 +253,7 @@ func (t *AppendObjectCreatorTest) ComposeObjectsReturnsNotFoundError() {
 		WillOnce(Return(nil, &gcs.NotFoundError{Err: errors.New("taco")}))
 
 	// DeleteObject
-	ExpectCall(t.bucket, "DeleteObject")(Any(), tmpObject.Name).
+	ExpectCall(t.bucket, "DeleteObject")(Any(), deleteReqName(tmpObject.Name)).
 		WillOnce(Return(errors.New("")))
 
 	// Call
@@ -254,7 +280,7 @@ func (t *AppendObjectCreatorTest) CallsDeleteObject() {
 		WillOnce(Return(composed, nil))
 
 	// DeleteObject
-	ExpectCall(t.bucket, "DeleteObject")(Any(), tmpObject.Name).
+	ExpectCall(t.bucket, "DeleteObject")(Any(), deleteReqName(tmpObject.Name)).
 		WillOnce(Return(errors.New("")))
 
 	// Call

gcsproxy/integration_test.go

@@ -374,7 +374,7 @@ func (t *IntegrationTest) WithinLeaserLimit() {
 	ExpectEq(fileLeaserLimitBytes, len(contents))
 
 	// Delete the backing object.
-	err = t.bucket.DeleteObject(t.ctx, o.Name)
+	err = t.bucket.DeleteObject(t.ctx, &gcs.DeleteObjectRequest{Name: o.Name})
 	AssertEq(nil, err)
 
 	// We should still be able to read the contents, because the read lease
@@ -409,7 +409,7 @@ func (t *IntegrationTest) LargerThanLeaserLimit() {
 	ExpectEq(fileLeaserLimitBytes+1, len(contents))
 
 	// Delete the backing object.
-	err = t.bucket.DeleteObject(t.ctx, o.Name)
+	err = t.bucket.DeleteObject(t.ctx, &gcs.DeleteObjectRequest{Name: o.Name})
 	AssertEq(nil, err)
 
 	// The contents should be lost, because the leaser should have revoked the
@@ -423,7 +423,7 @@ func (t *IntegrationTest) BackingObjectHasBeenDeleted_BeforeReading() {
 	o, err := gcsutil.CreateObject(t.ctx, t.bucket, "foo", "taco")
 	AssertEq(nil, err)
 
-	err = t.bucket.DeleteObject(t.ctx, o.Name)
+	err = t.bucket.DeleteObject(t.ctx, &gcs.DeleteObjectRequest{Name: o.Name})
 	AssertEq(nil, err)
 
 	// Create a mutable object around it.
@@ -459,7 +459,7 @@ func (t *IntegrationTest) BackingObjectHasBeenDeleted_AfterReading() {
 	AssertEq(nil, err)
 
 	// Delete the backing object.
-	err = t.bucket.DeleteObject(t.ctx, o.Name)
+	err = t.bucket.DeleteObject(t.ctx, &gcs.DeleteObjectRequest{Name: o.Name})
 	AssertEq(nil, err)
 
 	// Reading and modications should still work.

ratelimit/throttled_bucket.go

@@ -167,15 +167,15 @@ func (b *throttledBucket) UpdateObject(
 
 func (b *throttledBucket) DeleteObject(
 	ctx context.Context,
-	name string) (err error) {
+	req *gcs.DeleteObjectRequest) (err error) {
 	// Wait for permission to call through.
 	err = b.opThrottle.Wait(ctx, 1)
 	if err != nil {
 		return
 	}
 
 	// Call through.
-	err = b.wrapped.DeleteObject(ctx, name)
+	err = b.wrapped.DeleteObject(ctx, req)
 
 	return
 }