Revert "Refactor current GAE abstraction library to be free of the SDK*"

go/src/infra/gae/libs/wrapper/brokenfeatures.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 gae
+package wrapper
 
 import (
         "errors"
         "fmt"
         "runtime"
         "strings"
         "sync"
         "unicode"
         "unicode/utf8"
 )
@@ skipping 11 matching lines @@
 // would return the error.
 //
 // You may also pass nil as the error for BreakFeatures, and the fake will
 // provide some suitable (but generic) error for those features (like a
 // BAD_REQUEST or something like that).
 type FeatureBreaker interface {
         BreakFeatures(err error, feature ...string)
         UnbreakFeatures(feature ...string)
 }
 
-// ErrBrokenFeaturesBroken is returned from RunIfNotBroken when BrokenFeatures
-// itself isn't working correctly.
+// ErrBrokenFeaturesBroken is returned from IsBroken when BrokenFeatures itself
+// isn't working correctly.
 var ErrBrokenFeaturesBroken = errors.New("brokenFeatures: Unable to retrieve caller information")
 
 // BrokenFeatures implements the FeatureBreaker interface, and is suitable for
 // embedding within a fake service.
 type BrokenFeatures struct {
         lock sync.Mutex
 
         broken map[string]error
 
         // DefaultError is the default error to return when you call
@@ skipping 25 matching lines @@
 // features back to their original functionality.
 func (b *BrokenFeatures) UnbreakFeatures(feature ...string) {
         b.lock.Lock()
         defer b.lock.Unlock()
 
         for _, f := range feature {
                 delete(b.broken, f)
         }
 }
 
-// RunIfNotBroken is to be called internally by the fake service on every
-// publically-facing method. If it returns an error, the fake should return the
-// error.
+// IsBroken is to be called internally by the fake service on every
+// publically-facing method. If it returns an error, the fake should return
+// the error.
 //
 // Example:
 //   type MyService struct { BrokenFeatures }
 //   func (ms *MyService) Thingy() error {
-//     if err := ms.RunIfNotBroken(); err != nil {
+//     if err := ms.IsBroken(); err != nil {
 //       return err
 //     }
 //               ...
 //   }
 //
 //  You can now do ms.SetBrokenFeatures("Thingy"), and Thingy will return an
 //  error.
 //
-//  Note that RunIfNotBroken will keep walking the stack until it finds the
-//  first publically-exported method, which will allow you to put the
-//  RunIfNotBroken call in an internal helper method of your service
-//  implementation.
+//  Note that IsBroken will keep walking the stack until it finds the first
+//  publically-exported method, which will allow you to put the IsBroken call
+//  in an internal helper method of your service implementation.
 //
-//  Additionaly, RunIfNotBroken allows a very primitive form of overriding; it
-//  walks the stack until it finds the first method which is not called
-//  "RunIfNotBroken".  This allows the embedding struct to call into
-//  BrokenFeatures.RunIfNotBroken from another RunIfNotBroken function, and
-//  still have it behave correctly.
-func (b *BrokenFeatures) RunIfNotBroken(f func() error) error {
+//  Additionaly, IsBroken allows a very primitive form of overriding; it walks
+//  the stack until it finds the first method which is not called "IsBroken".
+//  This allows the embedding struct to call into BrokenFeatures.IsBroken from
+//  another IsBroken function, and still have it behave correctly.
+func (b *BrokenFeatures) IsBroken() error {
         if b.noBrokenFeatures() {
-                return f()
+                return nil
         }
 
         var name string
         for off := 1; ; off++ { // offset of 1 skips ourselves by default
                 // TODO(riannucci): Profile this to see if it's having an adverse
-                // performance impact on tests.
+                // performance impact ont tests.
                 fn, _, _, ok := runtime.Caller(off)
                 if !ok {
                         return ErrBrokenFeaturesBroken
                 }
                 toks := strings.Split(runtime.FuncForPC(fn).Name(), ".")
                 name = toks[len(toks)-1]
                 firstRune, _ := utf8.DecodeRuneInString(name)
                 if !unicode.IsUpper(firstRune) {
                         // unexported method, keep walking till we find the first exported
                         // method. Do !IsUpper, since exported is defined by IsUpper and not
                         // !IsLower, and afaik, in unicode-land they're not direct opposites.
                         continue
                 }
-                if name == "RunIfNotBroken" {
-                        // Allow users to override RunIfNotBroken, keep walking until we see
-                        // a function which is named differently than RunIfNotBroken.
+                if name == "IsBroken" {
+                        // Allow users to override IsBroken, keep walking until we see a function
+                        // which is named differently than IsBroken.
                         continue
                 }
                 break
         }
 
         b.lock.Lock()
-        err, ok := b.broken[name]
         defer b.lock.Unlock()
-
-        if ok {
+        if err, ok := b.broken[name]; ok {
                 if err != nil {
                         return err
                 }
                 if b.DefaultError != nil {
                         return b.DefaultError
                 }
                 return fmt.Errorf("feature %q is broken", name)
         }
 
-        return f()
+        return nil
 }
 
 func (b *BrokenFeatures) noBrokenFeatures() bool {
         b.lock.Lock()
         defer b.lock.Unlock()
         return len(b.broken) == 0
 }