Merge "Added a PoolCounterWorkViaCallback convenience class."

diff --cc includes/PoolCounter.php
index c6a3077,01a2047..38c6f04
--- 1/includes/PoolCounter.php
--- 2/includes/PoolCounter.php
+++ b/includes/PoolCounter.php
@@@ -246,4 -239,78 +246,74 @@@ abstract class PoolCounterWork 
                                return $this->error( $status );
                }
        }
 -
 -      function __construct( $type, $key ) {
 -              $this->poolCounter = PoolCounter::factory( $type, $key );
 -      }
  }
+ 
+ /**
+  * Convenience class for dealing with PoolCounters using callbacks
+  * @since 1.22
+  */
+ class PoolCounterWorkViaCallback extends PoolCounterWork {
+       /** @var callable */
+       protected $doWork;
+       /** @var callable|null */
+       protected $doCachedWork;
+       /** @var callable|null */
+       protected $fallback;
+       /** @var callable|null */
+       protected $error;
+ 
+       /**
+        * Build a PoolCounterWork class from a type, key, and callback map.
+        *
+        * The callback map must at least have a callback for the 'doWork' method.
+        * Additionally, callbacks can be provided for the 'doCachedWork', 'fallback',
+        * and 'error' methods. Methods without callbacks will be no-ops that return false.
+        * If a 'doCachedWork' callback is provided, then execute() may wait for any prior
+        * process in the pool to finish and reuse its cached result.
+        *
+        * @param string $type
+        * @param string $key
+        * @param array $callbacks Map of callbacks
+        * @throws MWException
+        */
+       public function __construct( $type, $key, array $callbacks ) {
+               parent::__construct( $type, $key );
+               foreach ( array( 'doWork', 'doCachedWork', 'fallback', 'error' ) as $name ) {
+                       if ( isset( $callbacks[$name] ) ) {
+                               if ( !is_callable( $callbacks[$name] ) ) {
+                                       throw new MWException( "Invalid callback provided for '$name' function." );
+                               }
+                               $this->$name = $callbacks[$name];
+                       }
+               }
+               if ( !isset( $this->doWork ) ) {
+                       throw new MWException( "No callback provided for 'doWork' function." );
+               }
+               $this->cacheable = isset( $this->doCachedWork );
+       }
+ 
+       public function doWork() {
+               return call_user_func_array( $this->doWork, array() );
+       }
+ 
+       public function getCachedWork() {
+               if ( $this->doCachedWork ) {
+                       return call_user_func_array( $this->doCachedWork, array() );
+               }
+               return false;
+       }
+ 
+       function fallback() {
+               if ( $this->fallback ) {
+                       return call_user_func_array( $this->fallback, array() );
+               }
+               return false;
+       }
+ 
+       function error( $status ) {
+               if ( $this->error ) {
+                       return call_user_func_array( $this->error, array( $status ) );
+               }
+               return false;
+       }
+ }