installed plugin W3 Total Cache version 2.3.2

wp-content/plugins/w3-total-cache/lib/Google/Auth/Abstract.php

@@ -0,0 +1,34 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Abstract class for the Authentication in the API client
+ * @author Chris Chabot <chabotc@google.com>
+ *
+ */
+abstract class W3TCG_Google_Auth_Abstract
+{
+  /**
+   * An utility function that first calls $this->auth->sign($request) and then
+   * executes makeRequest() on that signed request. Used for when a request
+   * should be authenticated
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request $request
+   */
+  abstract public function authenticatedRequest(W3TCG_Google_Http_Request $request);
+  abstract public function sign(W3TCG_Google_Http_Request $request);
+}

wp-content/plugins/w3-total-cache/lib/Google/Auth/AppIdentity.php

@@ -0,0 +1,100 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * WARNING - this class depends on the Google App Engine PHP library
+ * which is 5.3 and above only, so if you include this in a PHP 5.2
+ * setup or one without 5.3 things will blow up.
+ */
+use google\appengine\api\app_identity\AppIdentityService;
+
+/**
+ * Authentication via the Google App Engine App Identity service.
+ */
+class W3TCG_Google_Auth_AppIdentity extends W3TCG_Google_Auth_Abstract
+{
+  const CACHE_PREFIX = "W3TCG_Google_Auth_AppIdentity::";
+  private $key = null;
+  private $client;
+  private $token = false;
+  private $tokenScopes = false;
+
+  public function __construct(W3TCG_Google_Client $client, $config = null)
+  {
+    $this->client = $client;
+  }
+
+  /**
+   * Retrieve an access token for the scopes supplied.
+   */
+  public function authenticateForScope($scopes)
+  {
+    if ($this->token && $this->tokenScopes == $scopes) {
+      return $this->token;
+    }
+
+    $cacheKey = self::CACHE_PREFIX;
+    if (is_string($scopes)) {
+      $cacheKey .= $scopes;
+    } else if (is_array($scopes)) {
+      $cacheKey .= implode(":", $scopes);
+    }
+
+    $this->token = $this->client->getCache()->get($cacheKey);
+    if (!$this->token) {
+      $this->token = AppIdentityService::getAccessToken($scopes);
+      if ($this->token) {
+        $this->client->getCache()->set(
+            $cacheKey,
+            $this->token
+        );
+      }
+    }
+    $this->tokenScopes = $scopes;
+    return $this->token;
+  }
+
+  /**
+   * Perform an authenticated / signed apiHttpRequest.
+   * This function takes the apiHttpRequest, calls apiAuth->sign on it
+   * (which can modify the request in what ever way fits the auth mechanism)
+   * and then calls apiCurlIO::makeRequest on the signed request
+   *
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request The resulting HTTP response including the
+   * responseHttpCode, responseHeaders and responseBody.
+   */
+  public function authenticatedRequest(W3TCG_Google_Http_Request $request)
+  {
+    $request = $this->sign($request);
+    return $this->client->getIo()->makeRequest($request);
+  }
+
+  public function sign(W3TCG_Google_Http_Request $request)
+  {
+    if (!$this->token) {
+      // No token, so nothing to do.
+      return $request;
+    }
+    // Add the OAuth2 header to the request
+    $request->setRequestHeaders(
+        array('Authorization' => 'Bearer ' . $this->token['access_token'])
+    );
+
+    return $request;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Auth/AssertionCredentials.php

@@ -0,0 +1,134 @@
+<?php
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Credentials object used for OAuth 2.0 Signed JWT assertion grants.
+ *
+ * @author Chirag Shah <chirags@google.com>
+ */
+class W3TCG_Google_Auth_AssertionCredentials
+{
+  const MAX_TOKEN_LIFETIME_SECS = 3600;
+
+  public $serviceAccountName;
+  public $scopes;
+  public $privateKey;
+  public $privateKeyPassword;
+  public $assertionType;
+  public $sub;
+  /**
+   * @deprecated
+   * @link http://tools.ietf.org/html/draft-ietf-oauth-json-web-token-06
+   */
+  public $prn;
+  private $useCache;
+
+  /**
+   * @param $serviceAccountName
+   * @param $scopes array List of scopes
+   * @param $privateKey
+   * @param string $privateKeyPassword
+   * @param string $assertionType
+   * @param bool|string $sub The email address of the user for which the
+   *              application is requesting delegated access.
+   * @param bool useCache Whether to generate a cache key and allow
+   *              automatic caching of the generated token.
+   */
+  public function __construct(
+      $serviceAccountName,
+      $scopes,
+      $privateKey,
+      $privateKeyPassword = 'notasecret',
+      $assertionType = 'http://oauth.net/grant_type/jwt/1.0/bearer',
+      $sub = false,
+      $useCache = true
+  ) {
+    $this->serviceAccountName = $serviceAccountName;
+    $this->scopes = is_string($scopes) ? $scopes : implode(' ', $scopes);
+    $this->privateKey = $privateKey;
+    $this->privateKeyPassword = $privateKeyPassword;
+    $this->assertionType = $assertionType;
+    $this->sub = $sub;
+    $this->prn = $sub;
+    $this->useCache = $useCache;
+  }
+  
+  /**
+   * Generate a unique key to represent this credential.
+   * @return string
+   */
+  public function getCacheKey()
+  {
+    if (!$this->useCache) {
+      return false;
+    }
+    $h = $this->sub;
+    $h .= $this->assertionType;
+    $h .= $this->privateKey;
+    $h .= $this->scopes;
+    $h .= $this->serviceAccountName;
+    return md5($h);
+  }
+
+  public function generateAssertion()
+  {
+    $now = time();
+
+    $jwtParams = array(
+          'aud' => W3TCG_Google_Auth_OAuth2::OAUTH2_TOKEN_URI,
+          'scope' => $this->scopes,
+          'iat' => $now,
+          'exp' => $now + self::MAX_TOKEN_LIFETIME_SECS,
+          'iss' => $this->serviceAccountName,
+    );
+
+    if ($this->sub !== false) {
+      $jwtParams['sub'] = $this->sub;
+    } else if ($this->prn !== false) {
+      $jwtParams['prn'] = $this->prn;
+    }
+
+    return $this->makeSignedJwt($jwtParams);
+  }
+
+  /**
+   * Creates a signed JWT.
+   * @param array $payload
+   * @return string The signed JWT.
+   */
+  private function makeSignedJwt($payload)
+  {
+    $header = array('typ' => 'JWT', 'alg' => 'RS256');
+
+    $payload = json_encode($payload);
+    // Handle some overzealous escaping in PHP json that seemed to cause some errors
+    // with claimsets.
+    $payload = str_replace('\/', '/', $payload);
+
+    $segments = array(
+      W3TCG_Google_Utils::urlSafeB64Encode(json_encode($header)),
+      W3TCG_Google_Utils::urlSafeB64Encode($payload)
+    );
+
+    $signingInput = implode('.', $segments);
+    $signer = new W3TCG_Google_Signer_P12($this->privateKey, $this->privateKeyPassword);
+    $signature = $signer->sign($signingInput);
+    $segments[] = W3TCG_Google_Utils::urlSafeB64Encode($signature);
+
+    return implode(".", $segments);
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Auth/Exception.php

@@ -0,0 +1,20 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class W3TCG_Google_Auth_Exception extends W3TCG_Google_Exception
+{
+}

wp-content/plugins/w3-total-cache/lib/Google/Auth/LoginTicket.php

@@ -0,0 +1,67 @@
+<?php
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Class to hold information about an authenticated login.
+ *
+ * @author Brian Eaton <beaton@google.com>
+ */
+class W3TCG_Google_Auth_LoginTicket
+{
+  const USER_ATTR = "sub";
+
+  // Information from id token envelope.
+  private $envelope;
+
+  // Information from id token payload.
+  private $payload;
+
+  /**
+   * Creates a user based on the supplied token.
+   *
+   * @param string $envelope Header from a verified authentication token.
+   * @param string $payload Information from a verified authentication token.
+   */
+  public function __construct($envelope, $payload)
+  {
+    $this->envelope = $envelope;
+    $this->payload = $payload;
+  }
+
+  /**
+   * Returns the numeric identifier for the user.
+   * @throws W3TCG_Google_Auth_Exception
+   * @return
+   */
+  public function getUserId()
+  {
+    if (array_key_exists(self::USER_ATTR, $this->payload)) {
+      return $this->payload[self::USER_ATTR];
+    }
+    throw new W3TCG_Google_Auth_Exception("No user_id in token");
+  }
+
+  /**
+   * Returns attributes from the login ticket.  This can contain
+   * various information about the user session.
+   * @return array
+   */
+  public function getAttributes()
+  {
+    return array("envelope" => $this->envelope, "payload" => $this->payload);
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Auth/OAuth2.php

@@ -0,0 +1,618 @@
+<?php
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Authentication class that deals with the OAuth 2 web-server authentication flow
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ * @author Chirag Shah <chirags@google.com>
+ *
+ */
+class W3TCG_Google_Auth_OAuth2 extends W3TCG_Google_Auth_Abstract
+{
+  const OAUTH2_REVOKE_URI = 'https://accounts.google.com/o/oauth2/revoke';
+  const OAUTH2_TOKEN_URI = 'https://accounts.google.com/o/oauth2/token';
+  const OAUTH2_AUTH_URL = 'https://accounts.google.com/o/oauth2/auth';
+  const CLOCK_SKEW_SECS = 300; // five minutes in seconds
+  const AUTH_TOKEN_LIFETIME_SECS = 300; // five minutes in seconds
+  const MAX_TOKEN_LIFETIME_SECS = 86400; // one day in seconds
+  const OAUTH2_ISSUER = 'accounts.google.com';
+
+  /** @var W3TCG_Google_Auth_AssertionCredentials $assertionCredentials */
+  private $assertionCredentials;
+
+  /**
+   * @var string The state parameters for CSRF and other forgery protection.
+   */
+  private $state;
+
+  /**
+   * @var array The token bundle.
+   */
+  private $token = array();
+
+  /**
+   * @var W3TCG_Google_Client the base client
+   */
+  private $client;
+
+  /**
+   * Instantiates the class, but does not initiate the login flow, leaving it
+   * to the discretion of the caller.
+   */
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    $this->client = $client;
+  }
+
+  /**
+   * Perform an authenticated / signed apiHttpRequest.
+   * This function takes the apiHttpRequest, calls apiAuth->sign on it
+   * (which can modify the request in what ever way fits the auth mechanism)
+   * and then calls apiCurlIO::makeRequest on the signed request
+   *
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request The resulting HTTP response including the
+   * responseHttpCode, responseHeaders and responseBody.
+   */
+  public function authenticatedRequest(W3TCG_Google_Http_Request $request)
+  {
+    $request = $this->sign($request);
+    return $this->client->getIo()->makeRequest($request);
+  }
+
+  /**
+   * @param string $code
+   * @throws W3TCG_Google_Auth_Exception
+   * @return string
+   */
+  public function authenticate($code)
+  {
+    if (strlen($code) == 0) {
+      throw new W3TCG_Google_Auth_Exception("Invalid code");
+    }
+
+    // We got here from the redirect from a successful authorization grant,
+    // fetch the access token
+    $request = new W3TCG_Google_Http_Request(
+        self::OAUTH2_TOKEN_URI,
+        'POST',
+        array(),
+        array(
+          'code' => $code,
+          'grant_type' => 'authorization_code',
+          'redirect_uri' => $this->client->getClassConfig($this, 'redirect_uri'),
+          'client_id' => $this->client->getClassConfig($this, 'client_id'),
+          'client_secret' => $this->client->getClassConfig($this, 'client_secret')
+        )
+    );
+    $request->disableGzip();
+    $response = $this->client->getIo()->makeRequest($request);
+
+    if ($response->getResponseHttpCode() == 200) {
+      $this->setAccessToken($response->getResponseBody());
+      $this->token['created'] = time();
+      return $this->getAccessToken();
+    } else {
+      $decodedResponse = json_decode($response->getResponseBody(), true);
+      if ($decodedResponse != null && $decodedResponse['error']) {
+        $errorText = $decodedResponse['error'];
+        if (isset($decodedResponse['error_description'])) {
+          $errorText .= ": " . $decodedResponse['error_description'];
+        }
+      }
+      throw new W3TCG_Google_Auth_Exception(
+          sprintf(
+              "Error fetching OAuth2 access token, message: '%s'",
+              $errorText
+          ),
+          $response->getResponseHttpCode()
+      );
+    }
+  }
+
+  /**
+   * Create a URL to obtain user authorization.
+   * The authorization endpoint allows the user to first
+   * authenticate, and then grant/deny the access request.
+   * @param string $scope The scope is expressed as a list of space-delimited strings.
+   * @return string
+   */
+  public function createAuthUrl($scope)
+  {
+    $params = array(
+        'response_type' => 'code',
+        'redirect_uri' => $this->client->getClassConfig($this, 'redirect_uri'),
+        'client_id' => $this->client->getClassConfig($this, 'client_id'),
+        'scope' => $scope,
+        'access_type' => $this->client->getClassConfig($this, 'access_type'),
+    );
+
+    // Prefer prompt to approval prompt.
+    if ($this->client->getClassConfig($this, 'prompt')) {
+      $params = $this->maybeAddParam($params, 'prompt');
+    } else {
+      $params = $this->maybeAddParam($params, 'approval_prompt');
+    }
+    $params = $this->maybeAddParam($params, 'login_hint');
+    $params = $this->maybeAddParam($params, 'hd');
+    $params = $this->maybeAddParam($params, 'openid.realm');
+    $params = $this->maybeAddParam($params, 'include_granted_scopes');
+
+    // If the list of scopes contains plus.login, add request_visible_actions
+    // to auth URL.
+    $rva = $this->client->getClassConfig($this, 'request_visible_actions');
+    if (strpos($scope, 'plus.login') && strlen($rva) > 0) {
+        $params['request_visible_actions'] = $rva;
+    }
+
+    if (isset($this->state)) {
+      $params['state'] = $this->state;
+    }
+
+    return self::OAUTH2_AUTH_URL . "?" . http_build_query($params, '', '&');
+  }
+
+  /**
+   * @param string $token
+   * @throws W3TCG_Google_Auth_Exception
+   */
+  public function setAccessToken($token)
+  {
+    $token = json_decode($token, true);
+    if ($token == null) {
+      throw new W3TCG_Google_Auth_Exception('Could not json decode the token');
+    }
+    if (! isset($token['access_token'])) {
+      throw new W3TCG_Google_Auth_Exception("Invalid token format");
+    }
+    $this->token = $token;
+  }
+
+  public function getAccessToken()
+  {
+    return json_encode($this->token);
+  }
+
+  public function getRefreshToken()
+  {
+    if (array_key_exists('refresh_token', $this->token)) {
+      return $this->token['refresh_token'];
+    } else {
+      return null;
+    }
+  }
+
+  public function setState($state)
+  {
+    $this->state = $state;
+  }
+
+  public function setAssertionCredentials(W3TCG_Google_Auth_AssertionCredentials $creds)
+  {
+    $this->assertionCredentials = $creds;
+  }
+
+  /**
+   * Include an accessToken in a given apiHttpRequest.
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request
+   * @throws W3TCG_Google_Auth_Exception
+   */
+  public function sign(W3TCG_Google_Http_Request $request)
+  {
+    // add the developer key to the request before signing it
+    if ($this->client->getClassConfig($this, 'developer_key')) {
+      $request->setQueryParam('key', $this->client->getClassConfig($this, 'developer_key'));
+    }
+
+    // Cannot sign the request without an OAuth access token.
+    if (null == $this->token && null == $this->assertionCredentials) {
+      return $request;
+    }
+
+    // Check if the token is set to expire in the next 30 seconds
+    // (or has already expired).
+    if ($this->isAccessTokenExpired()) {
+      if ($this->assertionCredentials) {
+        $this->refreshTokenWithAssertion();
+      } else {
+        if (! array_key_exists('refresh_token', $this->token)) {
+            throw new W3TCG_Google_Auth_Exception(
+                "The OAuth 2.0 access token has expired,"
+                ." and a refresh token is not available. Refresh tokens"
+                ." are not returned for responses that were auto-approved."
+            );
+        }
+        $this->refreshToken($this->token['refresh_token']);
+      }
+    }
+
+    // Add the OAuth2 header to the request
+    $request->setRequestHeaders(
+        array('Authorization' => 'Bearer ' . $this->token['access_token'])
+    );
+
+    return $request;
+  }
+
+  /**
+   * Fetches a fresh access token with the given refresh token.
+   * @param string $refreshToken
+   * @return void
+   */
+  public function refreshToken($refreshToken)
+  {
+    $this->refreshTokenRequest(
+        array(
+          'client_id' => $this->client->getClassConfig($this, 'client_id'),
+          'client_secret' => $this->client->getClassConfig($this, 'client_secret'),
+          'refresh_token' => $refreshToken,
+          'grant_type' => 'refresh_token'
+        )
+    );
+  }
+
+  /**
+   * Fetches a fresh access token with a given assertion token.
+   * @param W3TCG_Google_Auth_AssertionCredentials $assertionCredentials optional.
+   * @return void
+   */
+  public function refreshTokenWithAssertion($assertionCredentials = null)
+  {
+    if (!$assertionCredentials) {
+      $assertionCredentials = $this->assertionCredentials;
+    }
+
+    $cacheKey = $assertionCredentials->getCacheKey();
+
+    if ($cacheKey) {
+      // We can check whether we have a token available in the
+      // cache. If it is expired, we can retrieve a new one from
+      // the assertion.
+      $token = $this->client->getCache()->get($cacheKey);
+      if ($token) {
+        $this->setAccessToken($token);
+      }
+      if (!$this->isAccessTokenExpired()) {
+        return;
+      }
+    }
+
+    $this->refreshTokenRequest(
+        array(
+          'grant_type' => 'assertion',
+          'assertion_type' => $assertionCredentials->assertionType,
+          'assertion' => $assertionCredentials->generateAssertion(),
+        )
+    );
+
+    if ($cacheKey) {
+      // Attempt to cache the token.
+      $this->client->getCache()->set(
+          $cacheKey,
+          $this->getAccessToken()
+      );
+    }
+  }
+
+  private function refreshTokenRequest($params)
+  {
+    $http = new W3TCG_Google_Http_Request(
+        self::OAUTH2_TOKEN_URI,
+        'POST',
+        array(),
+        $params
+    );
+    $http->disableGzip();
+    $request = $this->client->getIo()->makeRequest($http);
+
+    $code = $request->getResponseHttpCode();
+    $body = $request->getResponseBody();
+    if (200 == $code) {
+      $token = json_decode($body, true);
+      if ($token == null) {
+        throw new W3TCG_Google_Auth_Exception("Could not json decode the access token");
+      }
+
+      if (! isset($token['access_token']) || ! isset($token['expires_in'])) {
+        throw new W3TCG_Google_Auth_Exception("Invalid token format");
+      }
+
+      if (isset($token['id_token'])) {
+        $this->token['id_token'] = $token['id_token'];
+      }
+      $this->token['access_token'] = $token['access_token'];
+      $this->token['expires_in'] = $token['expires_in'];
+      $this->token['created'] = time();
+    } else {
+      throw new W3TCG_Google_Auth_Exception("Error refreshing the OAuth2 token, message: '$body'", $code);
+    }
+  }
+
+  /**
+   * Revoke an OAuth2 access token or refresh token. This method will revoke the current access
+   * token, if a token isn't provided.
+   * @throws W3TCG_Google_Auth_Exception
+   * @param string|null $token The token (access token or a refresh token) that should be revoked.
+   * @return boolean Returns True if the revocation was successful, otherwise False.
+   */
+  public function revokeToken($token = null)
+  {
+    if (!$token) {
+      if (!$this->token) {
+        // Not initialized, no token to actually revoke
+        return false;
+      } elseif (array_key_exists('refresh_token', $this->token)) {
+        $token = $this->token['refresh_token'];
+      } else {
+        $token = $this->token['access_token'];
+      }
+    }
+    $request = new W3TCG_Google_Http_Request(
+        self::OAUTH2_REVOKE_URI,
+        'POST',
+        array(),
+        "token=$token"
+    );
+    $request->disableGzip();
+    $response = $this->client->getIo()->makeRequest($request);
+    $code = $response->getResponseHttpCode();
+    if ($code == 200) {
+      $this->token = null;
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Returns if the access_token is expired.
+   * @return bool Returns True if the access_token is expired.
+   */
+  public function isAccessTokenExpired()
+  {
+    if (!$this->token || !isset($this->token['created'])) {
+      return true;
+    }
+
+    // If the token is set to expire in the next 30 seconds.
+    $expired = ($this->token['created']
+        + ($this->token['expires_in'] - 30)) < time();
+
+    return $expired;
+  }
+
+  // Gets federated sign-on certificates to use for verifying identity tokens.
+  // Returns certs as array structure, where keys are key ids, and values
+  // are PEM encoded certificates.
+  private function getFederatedSignOnCerts()
+  {
+    return $this->retrieveCertsFromLocation(
+        $this->client->getClassConfig($this, 'federated_signon_certs_url')
+    );
+  }
+
+  /**
+   * Retrieve and cache a certificates file.
+   *
+   * @param $url string location
+   * @throws W3TCG_Google_Auth_Exception
+   * @return array certificates
+   */
+  public function retrieveCertsFromLocation($url)
+  {
+    // If we're retrieving a local file, just grab it.
+    if ("http" != substr($url, 0, 4)) {
+      $file = file_get_contents($url);
+      if ($file) {
+        return json_decode($file, true);
+      } else {
+        throw new W3TCG_Google_Auth_Exception(
+            "Failed to retrieve verification certificates: '" .
+            $url . "'."
+        );
+      }
+    }
+
+    // This relies on makeRequest caching certificate responses.
+    $request = $this->client->getIo()->makeRequest(
+        new W3TCG_Google_Http_Request(
+            $url
+        )
+    );
+    if ($request->getResponseHttpCode() == 200) {
+      $certs = json_decode($request->getResponseBody(), true);
+      if ($certs) {
+        return $certs;
+      }
+    }
+    throw new W3TCG_Google_Auth_Exception(
+        "Failed to retrieve verification certificates: '" .
+        $request->getResponseBody() . "'.",
+        $request->getResponseHttpCode()
+    );
+  }
+
+  /**
+   * Verifies an id token and returns the authenticated apiLoginTicket.
+   * Throws an exception if the id token is not valid.
+   * The audience parameter can be used to control which id tokens are
+   * accepted.  By default, the id token must have been issued to this OAuth2 client.
+   *
+   * @param $id_token
+   * @param $audience
+   * @return W3TCG_Google_Auth_LoginTicket
+   */
+  public function verifyIdToken($id_token = null, $audience = null)
+  {
+    if (!$id_token) {
+      $id_token = $this->token['id_token'];
+    }
+    $certs = $this->getFederatedSignonCerts();
+    if (!$audience) {
+      $audience = $this->client->getClassConfig($this, 'client_id');
+    }
+
+    return $this->verifySignedJwtWithCerts($id_token, $certs, $audience, self::OAUTH2_ISSUER);
+  }
+
+  /**
+   * Verifies the id token, returns the verified token contents.
+   *
+   * @param $jwt string the token
+   * @param $certs array of certificates
+   * @param $required_audience string the expected consumer of the token
+   * @param [$issuer] the expected issues, defaults to Google
+   * @param [$max_expiry] the max lifetime of a token, defaults to MAX_TOKEN_LIFETIME_SECS
+   * @throws W3TCG_Google_Auth_Exception
+   * @return mixed token information if valid, false if not
+   */
+  public function verifySignedJwtWithCerts(
+      $jwt,
+      $certs,
+      $required_audience,
+      $issuer = null,
+      $max_expiry = null
+  ) {
+    if (!$max_expiry) {
+      // Set the maximum time we will accept a token for.
+      $max_expiry = self::MAX_TOKEN_LIFETIME_SECS;
+    }
+
+    $segments = explode(".", $jwt);
+    if (count($segments) != 3) {
+      throw new W3TCG_Google_Auth_Exception("Wrong number of segments in token: $jwt");
+    }
+    $signed = $segments[0] . "." . $segments[1];
+    $signature = W3TCG_Google_Utils::urlSafeB64Decode($segments[2]);
+
+    // Parse envelope.
+    $envelope = json_decode(W3TCG_Google_Utils::urlSafeB64Decode($segments[0]), true);
+    if (!$envelope) {
+      throw new W3TCG_Google_Auth_Exception("Can't parse token envelope: " . $segments[0]);
+    }
+
+    // Parse token
+    $json_body = W3TCG_Google_Utils::urlSafeB64Decode($segments[1]);
+    $payload = json_decode($json_body, true);
+    if (!$payload) {
+      throw new W3TCG_Google_Auth_Exception("Can't parse token payload: " . $segments[1]);
+    }
+
+    // Check signature
+    $verified = false;
+    foreach ($certs as $keyName => $pem) {
+      $public_key = new W3TCG_Google_Verifier_Pem($pem);
+      if ($public_key->verify($signed, $signature)) {
+        $verified = true;
+        break;
+      }
+    }
+
+    if (!$verified) {
+      throw new W3TCG_Google_Auth_Exception("Invalid token signature: $jwt");
+    }
+
+    // Check issued-at timestamp
+    $iat = 0;
+    if (array_key_exists("iat", $payload)) {
+      $iat = $payload["iat"];
+    }
+    if (!$iat) {
+      throw new W3TCG_Google_Auth_Exception("No issue time in token: $json_body");
+    }
+    $earliest = $iat - self::CLOCK_SKEW_SECS;
+
+    // Check expiration timestamp
+    $now = time();
+    $exp = 0;
+    if (array_key_exists("exp", $payload)) {
+      $exp = $payload["exp"];
+    }
+    if (!$exp) {
+      throw new W3TCG_Google_Auth_Exception("No expiration time in token: $json_body");
+    }
+    if ($exp >= $now + $max_expiry) {
+      throw new W3TCG_Google_Auth_Exception(
+          sprintf("Expiration time too far in future: %s", $json_body)
+      );
+    }
+
+    $latest = $exp + self::CLOCK_SKEW_SECS;
+    if ($now < $earliest) {
+      throw new W3TCG_Google_Auth_Exception(
+          sprintf(
+              "Token used too early, %s < %s: %s",
+              $now,
+              $earliest,
+              $json_body
+          )
+      );
+    }
+    if ($now > $latest) {
+      throw new W3TCG_Google_Auth_Exception(
+          sprintf(
+              "Token used too late, %s > %s: %s",
+              $now,
+              $latest,
+              $json_body
+          )
+      );
+    }
+
+    $iss = $payload['iss'];
+    if ($issuer && $iss != $issuer) {
+      throw new W3TCG_Google_Auth_Exception(
+          sprintf(
+              "Invalid issuer, %s != %s: %s",
+              $iss,
+              $issuer,
+              $json_body
+          )
+      );
+    }
+
+    // Check audience
+    $aud = $payload["aud"];
+    if ($aud != $required_audience) {
+      throw new W3TCG_Google_Auth_Exception(
+          sprintf(
+              "Wrong recipient, %s != %s:",
+              $aud,
+              $required_audience,
+              $json_body
+          )
+      );
+    }
+
+    // All good.
+    return new W3TCG_Google_Auth_LoginTicket($envelope, $payload);
+  }
+
+  /**
+   * Add a parameter to the auth params if not empty string.
+   */
+  private function maybeAddParam($params, $name)
+  {
+    $param = $this->client->getClassConfig($this, $name);
+    if ($param != '') {
+      $params[$name] = $param;
+    }
+    return $params;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Auth/Simple.php

@@ -0,0 +1,59 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Simple API access implementation. Can either be used to make requests
+ * completely unauthenticated, or by using a Simple API Access developer
+ * key.
+ * @author Chris Chabot <chabotc@google.com>
+ * @author Chirag Shah <chirags@google.com>
+ */
+class W3TCG_Google_Auth_Simple extends W3TCG_Google_Auth_Abstract
+{
+  private $key = null;
+  private $client;
+
+  public function __construct(W3TCG_Google_Client $client, $config = null)
+  {
+    $this->client = $client;
+  }
+
+  /**
+   * Perform an authenticated / signed apiHttpRequest.
+   * This function takes the apiHttpRequest, calls apiAuth->sign on it
+   * (which can modify the request in what ever way fits the auth mechanism)
+   * and then calls apiCurlIO::makeRequest on the signed request
+   *
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request The resulting HTTP response including the
+   * responseHttpCode, responseHeaders and responseBody.
+   */
+  public function authenticatedRequest(W3TCG_Google_Http_Request $request)
+  {
+    $request = $this->sign($request);
+    return $this->io->makeRequest($request);
+  }
+
+  public function sign(W3TCG_Google_Http_Request $request)
+  {
+    $key = $this->client->getClassConfig($this, 'developer_key');
+    if ($key) {
+      $request->setQueryParam('key', $key);
+    }
+    return $request;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Abstract.php

@@ -0,0 +1,53 @@
+<?php
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Abstract storage class
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+abstract class W3TCG_Google_Cache_Abstract
+{
+  
+  abstract public function __construct(W3TCG_Google_Client $client);
+
+  /**
+   * Retrieves the data for the given key, or false if they
+   * key is unknown or expired
+   *
+   * @param String $key The key who's data to retrieve
+   * @param boolean|int $expiration Expiration time in seconds
+   *
+   */
+  abstract public function get($key, $expiration = false);
+
+  /**
+   * Store the key => $value set. The $value is serialized
+   * by this function so can be of any type
+   *
+   * @param string $key Key of the data
+   * @param string $value data
+   */
+  abstract public function set($key, $value);
+
+  /**
+   * Removes the key/data pair for the given $key
+   *
+   * @param String $key
+   */
+  abstract public function delete($key);
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Apc.php

@@ -0,0 +1,70 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+/**
+ * A persistent storage class based on the APC cache, which is not
+ * really very persistent, as soon as you restart your web server
+ * the storage will be wiped, however for debugging and/or speed
+ * it can be useful, and cache is a lot cheaper then storage.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+class W3TCG_Google_Cache_Apc extends W3TCG_Google_Cache_Abstract
+{
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    if (! function_exists('apc_add') ) {
+      throw new W3TCG_Google_Cache_Exception("Apc functions not available");
+    }
+  }
+
+   /**
+   * @inheritDoc
+   */
+  public function get($key, $expiration = false)
+  {
+    $ret = apc_fetch($key);
+    if ($ret === false) {
+      return false;
+    }
+    if (is_numeric($expiration) && (time() - $ret['time'] > $expiration)) {
+      $this->delete($key);
+      return false;
+    }
+    return $ret['data'];
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public function set($key, $value)
+  {
+    $rc = apc_store($key, array('time' => time(), 'data' => $value));
+    if ($rc == false) {
+      throw new W3TCG_Google_Cache_Exception("Couldn't store data");
+    }
+  }
+
+  /**
+   * @inheritDoc
+   * @param String $key
+   */
+  public function delete($key)
+  {
+    apc_delete($key);
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Exception.php

@@ -0,0 +1,20 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class W3TCG_Google_Cache_Exception extends W3TCG_Google_Exception
+{
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/File.php

@@ -0,0 +1,142 @@
+<?php
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This class implements a basic on disk storage. While that does
+ * work quite well it's not the most elegant and scalable solution.
+ * It will also get you into a heap of trouble when you try to run
+ * this in a clustered environment.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+class W3TCG_Google_Cache_File extends W3TCG_Google_Cache_Abstract
+{
+  const MAX_LOCK_RETRIES = 10;
+  private $path;
+  private $fh;
+
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    $this->path = $client->getClassConfig($this, 'directory');
+  }
+  
+  public function get($key, $expiration = false)
+  {
+    $storageFile = $this->getCacheFile($key);
+    $data = false;
+    
+    if (!file_exists($storageFile)) {
+      return false;
+    }
+
+    if ($expiration) {
+      $mtime = filemtime($storageFile);
+      if ((time() - $mtime) >= $expiration) {
+        $this->delete($key);
+        return false;
+      }
+    }
+
+    if ($this->acquireReadLock($storageFile)) {
+      $data = fread($this->fh, filesize($storageFile));
+      $data =  unserialize($data);
+      $this->unlock($storageFile);
+    }
+
+    return $data;
+  }
+
+  public function set($key, $value)
+  {
+    $storageFile = $this->getWriteableCacheFile($key);
+    if ($this->acquireWriteLock($storageFile)) {
+      // We serialize the whole request object, since we don't only want the
+      // responseContent but also the postBody used, headers, size, etc.
+      $data = serialize($value);
+      $result = fwrite($this->fh, $data);
+      $this->unlock($storageFile);
+    }
+  }
+
+  public function delete($key)
+  {
+    $file = $this->getCacheFile($key);
+    if (file_exists($file) && !unlink($file)) {
+      throw new W3TCG_Google_Cache_Exception("Cache file could not be deleted");
+    }
+  }
+  
+  private function getWriteableCacheFile($file)
+  {
+    return $this->getCacheFile($file, true);
+  }
+
+  private function getCacheFile($file, $forWrite = false)
+  {
+    return $this->getCacheDir($file, $forWrite) . '/' . md5($file);
+  }
+  
+  private function getCacheDir($file, $forWrite)
+  {
+    // use the first 2 characters of the hash as a directory prefix
+    // this should prevent slowdowns due to huge directory listings
+    // and thus give some basic amount of scalability
+    $storageDir = $this->path . '/' . substr(md5($file), 0, 2);
+    if ($forWrite && ! is_dir($storageDir)) {
+      if (! mkdir($storageDir, 0755, true)) {
+        throw new W3TCG_Google_Cache_Exception("Could not create storage directory: $storageDir");
+      }
+    }
+    return $storageDir;
+  }
+  
+  private function acquireReadLock($storageFile)
+  {
+    return $this->acquireLock(LOCK_SH, $storageFile);
+  }
+  
+  private function acquireWriteLock($storageFile)
+  {
+    $rc = $this->acquireLock(LOCK_EX, $storageFile);
+    if (!$rc) {
+      $this->delete($storageFile);
+    }
+    return $rc;
+  }
+  
+  private function acquireLock($type, $storageFile)
+  {
+    $mode = $type == LOCK_EX ? "w" : "r";
+    $this->fh = fopen($storageFile, $mode);
+    $count = 0;
+    while (!flock($this->fh, $type | LOCK_NB)) {
+      // Sleep for 10ms.
+      usleep(10000);
+      if (++$count < self::MAX_LOCK_RETRIES) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  public function unlock($storageFile)
+  {
+    if ($this->fh) {
+      flock($this->fh, LOCK_UN);
+    }
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Memcache.php

@@ -0,0 +1,134 @@
+<?php
+/*
+ * Copyright 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A persistent storage class based on the memcache, which is not
+ * really very persistent, as soon as you restart your memcache daemon
+ * the storage will be wiped.
+ *
+ * Will use either the memcache or memcached extensions, preferring
+ * memcached.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ */
+class W3TCG_Google_Cache_Memcache extends W3TCG_Google_Cache_Abstract
+{
+  private $connection = false;
+  private $mc = false;
+  private $host;
+  private $port;
+
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    if (!function_exists('memcache_connect') && !class_exists("Memcached")) {
+      throw new W3TCG_Google_Cache_Exception("Memcache functions not available");
+    }
+    if ($client->isAppEngine()) {
+      // No credentials needed for GAE.
+      $this->mc = new Memcached();
+      $this->connection = true;
+    } else {
+      $this->host = $client->getClassConfig($this, 'host');
+      $this->port = $client->getClassConfig($this, 'port');
+      if (empty($this->host) || (empty($this->port) && (string) $this->port != "0")) {
+        throw new W3TCG_Google_Cache_Exception("You need to supply a valid memcache host and port");
+      }
+    }
+  }
+  
+  /**
+   * @inheritDoc
+   */
+  public function get($key, $expiration = false)
+  {
+    $this->connect();
+    $ret = false;
+    if ($this->mc) {
+      $ret = $this->mc->get($key);
+    } else {
+      $ret = memcache_get($this->connection, $key);
+    }
+    if ($ret === false) {
+      return false;
+    }
+    if (is_numeric($expiration) && (time() - $ret['time'] > $expiration)) {
+      $this->delete($key);
+      return false;
+    }
+    return $ret['data'];
+  }
+
+  /**
+   * @inheritDoc
+   * @param string $key
+   * @param string $value
+   * @throws W3TCG_Google_Cache_Exception
+   */
+  public function set($key, $value)
+  {
+    $this->connect();
+    // we store it with the cache_time default expiration so objects will at
+    // least get cleaned eventually.
+    $data = array('time' => time(), 'data' => $value);
+    $rc = false;
+    if ($this->mc) {
+      $rc = $this->mc->set($key, $data);
+    } else {
+      $rc = memcache_set($this->connection, $key, $data, false);
+    }
+    if ($rc == false) {
+      throw new W3TCG_Google_Cache_Exception("Couldn't store data in cache");
+    }
+  }
+
+  /**
+   * @inheritDoc
+   * @param String $key
+   */
+  public function delete($key)
+  {
+    $this->connect();
+    if ($this->mc) {
+      $this->mc->delete($key, 0);
+    } else {
+      memcache_delete($this->connection, $key, 0);
+    }
+  }
+
+  /**
+   * Lazy initialiser for memcache connection. Uses pconnect for to take 
+   * advantage of the persistence pool where possible. 
+   */
+  private function connect()
+  {
+    if ($this->connection) {
+      return;
+    }
+
+    if (class_exists("Memcached")) {
+      $this->mc = new Memcached();
+      $this->mc->addServer($this->host, $this->port);
+       $this->connection = true;
+    } else {
+      $this->connection = memcache_pconnect($this->host, $this->port);
+    }
+    
+    if (! $this->connection) {
+      throw new W3TCG_Google_Cache_Exception("Couldn't connect to memcache server");
+    }
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Cache/Null.php

@@ -0,0 +1,53 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A blank storage class, for cases where caching is not
+ * required.
+ */
+class W3TCG_Google_Cache_Null extends W3TCG_Google_Cache_Abstract
+{
+  public function __construct(W3TCG_Google_Client $client)
+  {
+
+  }
+
+   /**
+   * @inheritDoc
+   */
+  public function get($key, $expiration = false)
+  {
+    return false;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  public function set($key, $value)
+  {
+    // Nop.
+  }
+
+  /**
+   * @inheritDoc
+   * @param String $key
+   */
+  public function delete($key)
+  {
+    // Nop.
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Client.php

@@ -0,0 +1,656 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * The Google API Client
+ * http://code.google.com/p/google-api-php-client/
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ * @author Chirag Shah <chirags@google.com>
+ */
+class W3TCG_Google_Client
+{
+  const LIBVER = "1.1.0-beta";
+  const USER_AGENT_SUFFIX = "google-api-php-client/";
+  /**
+   * @var W3TCG_Google_Auth_Abstract $auth
+   */
+  private $auth;
+
+  /**
+   * @var W3TCG_Google_IO_Abstract $io
+   */
+  private $io;
+
+  /**
+   * @var W3TCG_Google_Cache_Abstract $cache
+   */
+  private $cache;
+
+  /**
+   * @var W3TCG_Google_Config $config
+   */
+  private $config;
+
+  /**
+   * @var boolean $deferExecution
+   */
+  private $deferExecution = false;
+
+  /** @var array $scopes */
+  // Scopes requested by the client
+  protected $requestedScopes = array();
+
+  // definitions of services that are discovered.
+  protected $services = array();
+
+  // Used to track authenticated state, can't discover services after doing authenticate()
+  private $authenticated = false;
+
+  /**
+   * Construct the Google Client.
+   *
+   * @param $config W3TCG_Google_Config or string for the ini file to load
+   */
+  public function __construct($config = null)
+  {
+    if (is_string($config) && strlen($config)) {
+      $config = new W3TCG_Google_Config($config);
+    } else if ( !($config instanceof W3TCG_Google_Config)) {
+      $config = new W3TCG_Google_Config();
+
+      if ($this->isAppEngine()) {
+        // Automatically use Memcache if we're in AppEngine.
+        $config->setCacheClass('W3TCG_Google_Cache_Memcache');
+      }
+
+      if (version_compare(phpversion(), "5.3.4", "<=") || $this->isAppEngine()) {
+        // Automatically disable compress.zlib, as currently unsupported.
+        $config->setClassConfig('W3TCG_Google_Http_Request', 'disable_gzip', true);
+      }
+    }
+
+    if ($config->getIoClass() == W3TCG_Google_Config::USE_AUTO_IO_SELECTION) {
+      if (function_exists('curl_version') && function_exists('curl_exec')) {
+        $config->setIoClass("W3TCG_Google_IO_Curl");
+      } else {
+        $config->setIoClass("W3TCG_Google_IO_Stream");
+      }
+    }
+
+    $this->config = $config;
+  }
+
+  /**
+   * Get a string containing the version of the library.
+   *
+   * @return string
+   */
+  public function getLibraryVersion()
+  {
+    return self::LIBVER;
+  }
+
+  /**
+   * Attempt to exchange a code for an valid authentication token.
+   * Helper wrapped around the OAuth 2.0 implementation.
+   *
+   * @param $code string code from accounts.google.com
+   * @return string token
+   */
+  public function authenticate($code)
+  {
+    $this->authenticated = true;
+    return $this->getAuth()->authenticate($code);
+  }
+
+  /**
+   * Set the auth config from the JSON string provided.
+   * This structure should match the file downloaded from
+   * the "Download JSON" button on in the Google Developer
+   * Console.
+   * @param string $json the configuration json
+   * @throws W3TCG_Google_Exception
+   */
+  public function setAuthConfig($json)
+  {
+    $data = json_decode($json);
+    $key = isset($data->installed) ? 'installed' : 'web';
+    if (!isset($data->$key)) {
+      throw new W3TCG_Google_Exception("Invalid client secret JSON file.");
+    }
+    $this->setClientId($data->$key->client_id);
+    $this->setClientSecret($data->$key->client_secret);
+    if (isset($data->$key->redirect_uris)) {
+      $this->setRedirectUri($data->$key->redirect_uris[0]);
+    }
+  }
+
+  /**
+   * Set the auth config from the JSON file in the path
+   * provided. This should match the file downloaded from
+   * the "Download JSON" button on in the Google Developer
+   * Console.
+   * @param string $file the file location of the client json
+   */
+  public function setAuthConfigFile($file)
+  {
+    $this->setAuthConfig(file_get_contents($file));
+  }
+
+  /**
+   * @throws W3TCG_Google_Auth_Exception
+   * @return array
+   * @visible For Testing
+   */
+  public function prepareScopes()
+  {
+    if (empty($this->requestedScopes)) {
+      throw new W3TCG_Google_Auth_Exception("No scopes specified");
+    }
+    $scopes = implode(' ', $this->requestedScopes);
+    return $scopes;
+  }
+
+  /**
+   * Set the OAuth 2.0 access token using the string that resulted from calling createAuthUrl()
+   * or W3TCG_Google_Client#getAccessToken().
+   * @param string $accessToken JSON encoded string containing in the following format:
+   * {"access_token":"TOKEN", "refresh_token":"TOKEN", "token_type":"Bearer",
+   *  "expires_in":3600, "id_token":"TOKEN", "created":1320790426}
+   */
+  public function setAccessToken($accessToken)
+  {
+    if ($accessToken == 'null') {
+      $accessToken = null;
+    }
+    $this->getAuth()->setAccessToken($accessToken);
+  }
+
+
+
+  /**
+   * Set the authenticator object
+   * @param W3TCG_Google_Auth_Abstract $auth
+   */
+  public function setAuth(W3TCG_Google_Auth_Abstract $auth)
+  {
+    $this->config->setAuthClass(get_class($auth));
+    $this->auth = $auth;
+  }
+
+  /**
+   * Set the IO object
+   * @param W3TCG_Google_IO_Abstract $io
+   */
+  public function setIo(W3TCG_Google_IO_Abstract $io)
+  {
+    $this->config->setIoClass(get_class($io));
+    $this->io = $io;
+  }
+
+  /**
+   * Set the Cache object
+   * @param W3TCG_Google_Cache_Abstract $cache
+   */
+  public function setCache(W3TCG_Google_Cache_Abstract $cache)
+  {
+    $this->config->setCacheClass(get_class($cache));
+    $this->cache = $cache;
+  }
+
+  /**
+   * Construct the OAuth 2.0 authorization request URI.
+   * @return string
+   */
+  public function createAuthUrl()
+  {
+    $scopes = $this->prepareScopes();
+    return $this->getAuth()->createAuthUrl($scopes);
+  }
+
+  /**
+   * Get the OAuth 2.0 access token.
+   * @return string $accessToken JSON encoded string in the following format:
+   * {"access_token":"TOKEN", "refresh_token":"TOKEN", "token_type":"Bearer",
+   *  "expires_in":3600,"id_token":"TOKEN", "created":1320790426}
+   */
+  public function getAccessToken()
+  {
+    $token = $this->getAuth()->getAccessToken();
+    // The response is json encoded, so could be the string null.
+    // It is arguable whether this check should be here or lower
+    // in the library.
+    return (null == $token || 'null' == $token || '[]' == $token) ? null : $token;
+  }
+
+  /**
+   * Get the OAuth 2.0 refresh token.
+   * @return string $refreshToken refresh token or null if not available
+   */
+  public function getRefreshToken()
+  {
+    return $this->getAuth()->getRefreshToken();
+  }
+
+  /**
+   * Returns if the access_token is expired.
+   * @return bool Returns True if the access_token is expired.
+   */
+  public function isAccessTokenExpired()
+  {
+    return $this->getAuth()->isAccessTokenExpired();
+  }
+
+  /**
+   * Set OAuth 2.0 "state" parameter to achieve per-request customization.
+   * @see http://tools.ietf.org/html/draft-ietf-oauth-v2-22#section-3.1.2.2
+   * @param string $state
+   */
+  public function setState($state)
+  {
+    $this->getAuth()->setState($state);
+  }
+
+  /**
+   * @param string $accessType Possible values for access_type include:
+   *  {@code "offline"} to request offline access from the user.
+   *  {@code "online"} to request online access from the user.
+   */
+  public function setAccessType($accessType)
+  {
+    $this->config->setAccessType($accessType);
+  }
+
+  /**
+   * @param string $approvalPrompt Possible values for approval_prompt include:
+   *  {@code "force"} to force the approval UI to appear. (This is the default value)
+   *  {@code "auto"} to request auto-approval when possible.
+   */
+  public function setApprovalPrompt($approvalPrompt)
+  {
+    $this->config->setApprovalPrompt($approvalPrompt);
+  }
+
+  /**
+   * Set the login hint, email address or sub id.
+   * @param string $loginHint
+   */
+  public function setLoginHint($loginHint)
+  {
+      $this->config->setLoginHint($loginHint);
+  }
+
+  /**
+   * Set the application name, this is included in the User-Agent HTTP header.
+   * @param string $applicationName
+   */
+  public function setApplicationName($applicationName)
+  {
+    $this->config->setApplicationName($applicationName);
+  }
+
+  /**
+   * Set the OAuth 2.0 Client ID.
+   * @param string $clientId
+   */
+  public function setClientId($clientId)
+  {
+    $this->config->setClientId($clientId);
+  }
+
+  /**
+   * Set the OAuth 2.0 Client Secret.
+   * @param string $clientSecret
+   */
+  public function setClientSecret($clientSecret)
+  {
+    $this->config->setClientSecret($clientSecret);
+  }
+
+  /**
+   * Set the OAuth 2.0 Redirect URI.
+   * @param string $redirectUri
+   */
+  public function setRedirectUri($redirectUri)
+  {
+    $this->config->setRedirectUri($redirectUri);
+  }
+
+  /**
+   * If 'plus.login' is included in the list of requested scopes, you can use
+   * this method to define types of app activities that your app will write.
+   * You can find a list of available types here:
+   * @link https://developers.google.com/+/api/moment-types
+   *
+   * @param array $requestVisibleActions Array of app activity types
+   */
+  public function setRequestVisibleActions($requestVisibleActions)
+  {
+    if (is_array($requestVisibleActions)) {
+      $requestVisibleActions = join(" ", $requestVisibleActions);
+    }
+    $this->config->setRequestVisibleActions($requestVisibleActions);
+  }
+
+  /**
+   * Set the developer key to use, these are obtained through the API Console.
+   * @see http://code.google.com/apis/console-help/#generatingdevkeys
+   * @param string $developerKey
+   */
+  public function setDeveloperKey($developerKey)
+  {
+    $this->config->setDeveloperKey($developerKey);
+  }
+
+  /**
+   * Set the hd (hosted domain) parameter streamlines the login process for
+   * Google Apps hosted accounts. By including the domain of the user, you
+   * restrict sign-in to accounts at that domain.
+   * @param $hd string - the domain to use.
+   */
+  public function setHostedDomain($hd)
+  {
+    $this->config->setHostedDomain($hd);
+  }
+
+  /**
+   * Set the prompt hint. Valid values are none, consent and select_account.
+   * If no value is specified and the user has not previously authorized
+   * access, then the user is shown a consent screen.
+   * @param $prompt string
+   */
+  public function setPrompt($prompt)
+  {
+    $this->config->setPrompt($prompt);
+  }
+
+  /**
+   * openid.realm is a parameter from the OpenID 2.0 protocol, not from OAuth
+   * 2.0. It is used in OpenID 2.0 requests to signify the URL-space for which
+   * an authentication request is valid.
+   * @param $realm string - the URL-space to use.
+   */
+  public function setOpenidRealm($realm)
+  {
+    $this->config->setOpenidRealm($realm);
+  }
+
+  /**
+   * If this is provided with the value true, and the authorization request is
+   * granted, the authorization will include any previous authorizations
+   * granted to this user/application combination for other scopes.
+   * @param $include boolean - the URL-space to use.
+   */
+  public function setIncludeGrantedScopes($include)
+  {
+    $this->config->setIncludeGrantedScopes($include);
+  }
+
+  /**
+   * Fetches a fresh OAuth 2.0 access token with the given refresh token.
+   * @param string $refreshToken
+   */
+  public function refreshToken($refreshToken)
+  {
+    $this->getAuth()->refreshToken($refreshToken);
+  }
+
+  /**
+   * Revoke an OAuth2 access token or refresh token. This method will revoke the current access
+   * token, if a token isn't provided.
+   * @throws W3TCG_Google_Auth_Exception
+   * @param string|null $token The token (access token or a refresh token) that should be revoked.
+   * @return boolean Returns True if the revocation was successful, otherwise False.
+   */
+  public function revokeToken($token = null)
+  {
+    return $this->getAuth()->revokeToken($token);
+  }
+
+  /**
+   * Verify an id_token. This method will verify the current id_token, if one
+   * isn't provided.
+   * @throws W3TCG_Google_Auth_Exception
+   * @param string|null $token The token (id_token) that should be verified.
+   * @return W3TCG_Google_Auth_LoginTicket Returns an apiLoginTicket if the verification was
+   * successful.
+   */
+  public function verifyIdToken($token = null)
+  {
+    return $this->getAuth()->verifyIdToken($token);
+  }
+
+  /**
+   * Verify a JWT that was signed with your own certificates.
+   *
+   * @param $id_token string The JWT token
+   * @param $cert_location array of certificates
+   * @param $audience string the expected consumer of the token
+   * @param $issuer string the expected issuer, defaults to Google
+   * @param [$max_expiry] the max lifetime of a token, defaults to MAX_TOKEN_LIFETIME_SECS
+   * @return mixed token information if valid, false if not
+   */
+  public function verifySignedJwt($id_token, $cert_location, $audience, $issuer, $max_expiry = null)
+  {
+    $auth = new W3TCG_Google_Auth_OAuth2($this);
+    $certs = $auth->retrieveCertsFromLocation($cert_location);
+    return $auth->verifySignedJwtWithCerts($id_token, $certs, $audience, $issuer, $max_expiry);
+  }
+
+  /**
+   * @param $creds W3TCG_Google_Auth_AssertionCredentials
+   */
+  public function setAssertionCredentials(W3TCG_Google_Auth_AssertionCredentials $creds)
+  {
+    $this->getAuth()->setAssertionCredentials($creds);
+  }
+
+  /**
+   * Set the scopes to be requested. Must be called before createAuthUrl().
+   * Will remove any previously configured scopes.
+   * @param array $scopes, ie: array('https://www.googleapis.com/auth/plus.login',
+   * 'https://www.googleapis.com/auth/moderator')
+   */
+  public function setScopes($scopes)
+  {
+    $this->requestedScopes = array();
+    $this->addScope($scopes);
+  }
+
+  /**
+   * This functions adds a scope to be requested as part of the OAuth2.0 flow.
+   * Will append any scopes not previously requested to the scope parameter.
+   * A single string will be treated as a scope to request. An array of strings
+   * will each be appended.
+   * @param $scope_or_scopes string|array e.g. "profile"
+   */
+  public function addScope($scope_or_scopes)
+  {
+    if (is_string($scope_or_scopes) && !in_array($scope_or_scopes, $this->requestedScopes)) {
+      $this->requestedScopes[] = $scope_or_scopes;
+    } else if (is_array($scope_or_scopes)) {
+      foreach ($scope_or_scopes as $scope) {
+        $this->addScope($scope);
+      }
+    }
+  }
+
+  /**
+   * Returns the list of scopes requested by the client
+   * @return array the list of scopes
+   *
+   */
+  public function getScopes()
+  {
+     return $this->requestedScopes;
+  }
+
+  /**
+   * Declare whether batch calls should be used. This may increase throughput
+   * by making multiple requests in one connection.
+   *
+   * @param boolean $useBatch True if the batch support should
+   * be enabled. Defaults to False.
+   */
+  public function setUseBatch($useBatch)
+  {
+    // This is actually an alias for setDefer.
+    $this->setDefer($useBatch);
+  }
+
+  /**
+   * Declare whether making API calls should make the call immediately, or
+   * return a request which can be called with ->execute();
+   *
+   * @param boolean $defer True if calls should not be executed right away.
+   */
+  public function setDefer($defer)
+  {
+    $this->deferExecution = $defer;
+  }
+
+  /**
+   * Helper method to execute deferred HTTP requests.
+   *
+   * @param $request W3TCG_Google_Http_Request|Google_Http_Batch
+   * @throws W3TCG_Google_Exception
+   * @return object of the type of the expected class or array.
+   */
+  public function execute($request)
+  {
+    if ($request instanceof W3TCG_Google_Http_Request) {
+      $request->setUserAgent(
+          $this->getApplicationName()
+          . " " . self::USER_AGENT_SUFFIX
+          . $this->getLibraryVersion()
+      );
+      if (!$this->getClassConfig("W3TCG_Google_Http_Request", "disable_gzip")) {
+        $request->enableGzip();
+      }
+      $request->maybeMoveParametersToBody();
+      return W3TCG_Google_Http_REST::execute($this, $request);
+    } else if ($request instanceof W3TCG_Google_Http_Batch) {
+      return $request->execute();
+    } else {
+      throw new W3TCG_Google_Exception("Do not know how to execute this type of object.");
+    }
+  }
+
+  /**
+   * Whether or not to return raw requests
+   * @return boolean
+   */
+  public function shouldDefer()
+  {
+    return $this->deferExecution;
+  }
+
+  /**
+   * @return W3TCG_Google_Auth_Abstract Authentication implementation
+   */
+  public function getAuth()
+  {
+    if (!isset($this->auth)) {
+      $class = $this->config->getAuthClass();
+      $this->auth = new $class($this);
+    }
+    return $this->auth;
+  }
+
+  /**
+   * @return W3TCG_Google_IO_Abstract IO implementation
+   */
+  public function getIo()
+  {
+    if (!isset($this->io)) {
+      $class = $this->config->getIoClass();
+      $this->io = new $class($this);
+    }
+    return $this->io;
+  }
+
+  /**
+   * @return W3TCG_Google_Cache_Abstract Cache implementation
+   */
+  public function getCache()
+  {
+    if (!isset($this->cache)) {
+      $class = $this->config->getCacheClass();
+      $this->cache = new $class($this);
+    }
+    return $this->cache;
+  }
+
+  /**
+   * Retrieve custom configuration for a specific class.
+   * @param $class string|object - class or instance of class to retrieve
+   * @param $key string optional - key to retrieve
+   * @return array
+   */
+  public function getClassConfig($class, $key = null)
+  {
+    if (!is_string($class)) {
+      $class = get_class($class);
+    }
+    return $this->config->getClassConfig($class, $key);
+  }
+
+  /**
+   * Set configuration specific to a given class.
+   * $config->setClassConfig('W3TCG_Google_Cache_File',
+   *   array('directory' => '/tmp/cache'));
+   * @param $class string|object - The class name for the configuration
+   * @param $config string key or an array of configuration values
+   * @param $value string optional - if $config is a key, the value
+   *
+   */
+  public function setClassConfig($class, $config, $value = null)
+  {
+    if (!is_string($class)) {
+      $class = get_class($class);
+    }
+    $this->config->setClassConfig($class, $config, $value);
+
+  }
+
+  /**
+   * @return string the base URL to use for calls to the APIs
+   */
+  public function getBasePath()
+  {
+    return $this->config->getBasePath();
+  }
+
+  /**
+   * @return string the name of the application
+   */
+  public function getApplicationName()
+  {
+    return $this->config->getApplicationName();
+  }
+
+  /**
+   * Are we running in Google AppEngine?
+   * return bool
+   */
+  public function isAppEngine()
+  {
+    return (isset($_SERVER['SERVER_SOFTWARE']) &&
+        strpos( sanitize_text_field( wp_unslash( $_SERVER['SERVER_SOFTWARE'] ) ), 'Google App Engine') !== false);
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Collection.php

@@ -0,0 +1,94 @@
+<?php
+
+/**
+ * Extension to the regular W3TCG_Google_Model that automatically
+ * exposes the items array for iteration, so you can just
+ * iterate over the object rather than a reference inside.
+ */
+class W3TCG_Google_Collection extends W3TCG_Google_Model implements Iterator, Countable
+{
+  protected $collection_key = 'items';
+
+  public function rewind()
+  {
+    if (isset($this->modelData[$this->collection_key])
+        && is_array($this->modelData[$this->collection_key])) {
+      reset($this->modelData[$this->collection_key]);
+    }
+  }
+
+  public function current()
+  {
+    $this->coerceType($this->key());
+    if (is_array($this->modelData[$this->collection_key])) {
+      return current($this->modelData[$this->collection_key]);
+    }
+  }
+
+  public function key()
+  {
+    if (isset($this->modelData[$this->collection_key])
+        && is_array($this->modelData[$this->collection_key])) {
+      return key($this->modelData[$this->collection_key]);
+    }
+  }
+
+  public function next()
+  {
+    return next($this->modelData[$this->collection_key]);
+  }
+
+  public function valid()
+  {
+    $key = $this->key();
+    return $key !== null && $key !== false;
+  }
+
+  public function count()
+  {
+    return count($this->modelData[$this->collection_key]);
+  }
+
+  public function offsetExists ($offset)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetExists($offset);
+    }
+    return isset($this->modelData[$this->collection_key][$offset]);
+  }
+
+  public function offsetGet($offset)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetGet($offset);
+    }
+    $this->coerceType($offset);
+    return $this->modelData[$this->collection_key][$offset];
+  }
+
+  public function offsetSet($offset, $value)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetSet($offset, $value);
+    }
+    $this->modelData[$this->collection_key][$offset] = $value;
+  }
+
+  public function offsetUnset($offset)
+  {
+    if (!is_numeric($offset)) {
+      return parent::offsetUnset($offset);
+    }
+    unset($this->modelData[$this->collection_key][$offset]);
+  }
+
+  private function coerceType($offset)
+  {
+    $typeKey = $this->keyType($this->collection_key);
+    if (isset($this->$typeKey) && !is_object($this->modelData[$this->collection_key][$offset])) {
+      $type = $this->$typeKey;
+      $this->modelData[$this->collection_key][$offset] =
+          new $type($this->modelData[$this->collection_key][$offset]);
+    }
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Config.php

@@ -0,0 +1,373 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A class to contain the library configuration for the Google API client.
+ */
+class W3TCG_Google_Config
+{
+  const GZIP_DISABLED = true;
+  const GZIP_ENABLED = false;
+  const GZIP_UPLOADS_ENABLED = true;
+  const GZIP_UPLOADS_DISABLED = false;
+  const USE_AUTO_IO_SELECTION = "auto";
+  protected $configuration;
+
+  /**
+   * Create a new W3TCG_Google_Config. Can accept an ini file location with the
+   * local configuration. For example:
+   *     application_name="My App"
+   *
+   * @param [$ini_file_location] - optional - The location of the ini file to load
+   */
+  public function __construct($ini_file_location = null)
+  {
+    $this->configuration = array(
+      // The application_name is included in the User-Agent HTTP header.
+      'application_name' => '',
+
+      // Which Authentication, Storage and HTTP IO classes to use.
+      'auth_class'    => 'W3TCG_Google_Auth_OAuth2',
+      'io_class'      => self::USE_AUTO_IO_SELECTION,
+      'cache_class'   => 'W3TCG_Google_Cache_File',
+
+      // Don't change these unless you're working against a special development
+      // or testing environment.
+      'base_path' => 'https://www.googleapis.com',
+
+      // Definition of class specific values, like file paths and so on.
+      'classes' => array(
+        'W3TCG_Google_IO_Abstract' => array(
+          'request_timeout_seconds' => 100,
+        ),
+        'W3TCG_Google_Http_Request' => array(
+          // Disable the use of gzip on calls if set to true. Defaults to false.
+          'disable_gzip' => self::GZIP_ENABLED,
+
+          // We default gzip to disabled on uploads even if gzip is otherwise
+          // enabled, due to some issues seen with small packet sizes for uploads.
+          // Please test with this option before enabling gzip for uploads in
+          // a production environment.
+          'enable_gzip_for_uploads' => self::GZIP_UPLOADS_DISABLED,
+        ),
+        // If you want to pass in OAuth 2.0 settings, they will need to be
+        // structured like this.
+        'W3TCG_Google_Auth_OAuth2' => array(
+          // Keys for OAuth 2.0 access, see the API console at
+          // https://developers.google.com/console
+          'client_id' => '',
+          'client_secret' => '',
+          'redirect_uri' => '',
+
+          // Simple API access key, also from the API console. Ensure you get
+          // a Server key, and not a Browser key.
+          'developer_key' => '',
+
+          // Other parameters.
+          'hd' => '',
+          'prompt' => '',
+          'openid.realm' => '',
+          'include_granted_scopes' => '',
+          'login_hint' => '',
+          'request_visible_actions' => '',
+          'access_type' => 'online',
+          'approval_prompt' => 'auto',
+          'federated_signon_certs_url' =>
+              'https://www.googleapis.com/oauth2/v1/certs',
+        ),
+        // Set a default directory for the file cache.
+        'W3TCG_Google_Cache_File' => array(
+          'directory' => sys_get_temp_dir() . '/W3TCG_Google_Client'
+        )
+      ),
+    );
+    if ($ini_file_location) {
+      $ini = parse_ini_file($ini_file_location, true);
+      if (is_array($ini) && count($ini)) {
+        $this->configuration = array_merge($this->configuration, $ini);
+      }
+    }
+  }
+
+  /**
+   * Set configuration specific to a given class.
+   * $config->setClassConfig('W3TCG_Google_Cache_File',
+   *   array('directory' => '/tmp/cache'));
+   * @param $class string The class name for the configuration
+   * @param $config string key or an array of configuration values
+   * @param $value string optional - if $config is a key, the value
+   */
+  public function setClassConfig($class, $config, $value = null)
+  {
+    if (!is_array($config)) {
+      if (!isset($this->configuration['classes'][$class])) {
+        $this->configuration['classes'][$class] = array();
+      }
+      $this->configuration['classes'][$class][$config] = $value;
+    } else {
+      $this->configuration['classes'][$class] = $config;
+    }
+  }
+
+  public function getClassConfig($class, $key = null)
+  {
+    if (!isset($this->configuration['classes'][$class])) {
+      return null;
+    }
+    if ($key === null) {
+      return $this->configuration['classes'][$class];
+    } else {
+      return $this->configuration['classes'][$class][$key];
+    }
+  }
+
+  /**
+   * Return the configured cache class.
+   * @return string
+   */
+  public function getCacheClass()
+  {
+    return $this->configuration['cache_class'];
+  }
+
+  /**
+   * Return the configured Auth class.
+   * @return string
+   */
+  public function getAuthClass()
+  {
+    return $this->configuration['auth_class'];
+  }
+
+  /**
+   * Set the auth class.
+   *
+   * @param $class string the class name to set
+   */
+  public function setAuthClass($class)
+  {
+    $prev = $this->configuration['auth_class'];
+    if (!isset($this->configuration['classes'][$class]) &&
+        isset($this->configuration['classes'][$prev])) {
+      $this->configuration['classes'][$class] =
+          $this->configuration['classes'][$prev];
+    }
+    $this->configuration['auth_class'] = $class;
+  }
+
+  /**
+   * Set the IO class.
+   *
+   * @param $class string the class name to set
+   */
+  public function setIoClass($class)
+  {
+    $prev = $this->configuration['io_class'];
+    if (!isset($this->configuration['classes'][$class]) &&
+        isset($this->configuration['classes'][$prev])) {
+      $this->configuration['classes'][$class] =
+          $this->configuration['classes'][$prev];
+    }
+    $this->configuration['io_class'] = $class;
+  }
+
+  /**
+   * Set the cache class.
+   *
+   * @param $class string the class name to set
+   */
+  public function setCacheClass($class)
+  {
+    $prev = $this->configuration['cache_class'];
+    if (!isset($this->configuration['classes'][$class]) &&
+        isset($this->configuration['classes'][$prev])) {
+      $this->configuration['classes'][$class] =
+          $this->configuration['classes'][$prev];
+    }
+    $this->configuration['cache_class'] = $class;
+  }
+
+  /**
+   * Return the configured IO class.
+   *
+   * @return string
+   */
+  public function getIoClass()
+  {
+    return $this->configuration['io_class'];
+  }
+
+  /**
+   * Set the application name, this is included in the User-Agent HTTP header.
+   * @param string $name
+   */
+  public function setApplicationName($name)
+  {
+    $this->configuration['application_name'] = $name;
+  }
+
+  /**
+   * @return string the name of the application
+   */
+  public function getApplicationName()
+  {
+    return $this->configuration['application_name'];
+  }
+
+  /**
+   * Set the client ID for the auth class.
+   * @param $clientId string - the API console client ID
+   */
+  public function setClientId($clientId)
+  {
+    $this->setAuthConfig('client_id', $clientId);
+  }
+
+  /**
+   * Set the client secret for the auth class.
+   * @param $secret string - the API console client secret
+   */
+  public function setClientSecret($secret)
+  {
+    $this->setAuthConfig('client_secret', $secret);
+  }
+
+  /**
+   * Set the redirect uri for the auth class. Note that if using the
+   * Javascript based sign in flow, this should be the string 'postmessage'.
+   *
+   * @param $uri string - the URI that users should be redirected to
+   */
+  public function setRedirectUri($uri)
+  {
+    $this->setAuthConfig('redirect_uri', $uri);
+  }
+
+  /**
+   * Set the app activities for the auth class.
+   * @param $rva string a space separated list of app activity types
+   */
+  public function setRequestVisibleActions($rva)
+  {
+    $this->setAuthConfig('request_visible_actions', $rva);
+  }
+
+  /**
+   * Set the the access type requested (offline or online.)
+   * @param $access string - the access type
+   */
+  public function setAccessType($access)
+  {
+    $this->setAuthConfig('access_type', $access);
+  }
+
+  /**
+   * Set when to show the approval prompt (auto or force)
+   * @param $approval string - the approval request
+   */
+  public function setApprovalPrompt($approval)
+  {
+    $this->setAuthConfig('approval_prompt', $approval);
+  }
+
+  /**
+   * Set the login hint (email address or sub identifier)
+   * @param $hint string
+   */
+  public function setLoginHint($hint)
+  {
+    $this->setAuthConfig('login_hint', $hint);
+  }
+
+  /**
+   * Set the developer key for the auth class. Note that this is separate value
+   * from the client ID - if it looks like a URL, its a client ID!
+   * @param $key string - the API console developer key
+   */
+  public function setDeveloperKey($key)
+  {
+    $this->setAuthConfig('developer_key', $key);
+  }
+
+  /**
+   * Set the hd (hosted domain) parameter streamlines the login process for
+   * Google Apps hosted accounts. By including the domain of the user, you
+   * restrict sign-in to accounts at that domain.
+   * @param $hd string - the domain to use.
+   */
+  public function setHostedDomain($hd)
+  {
+    $this->setAuthConfig('hd', $hd);
+  }
+
+  /**
+   * Set the prompt hint. Valid values are none, consent and select_account.
+   * If no value is specified and the user has not previously authorized
+   * access, then the user is shown a consent screen.
+   * @param $prompt string
+   */
+  public function setPrompt($prompt)
+  {
+    $this->setAuthConfig('prompt', $prompt);
+  }
+
+  /**
+   * openid.realm is a parameter from the OpenID 2.0 protocol, not from OAuth
+   * 2.0. It is used in OpenID 2.0 requests to signify the URL-space for which
+   * an authentication request is valid.
+   * @param $realm string - the URL-space to use.
+   */
+  public function setOpenidRealm($realm)
+  {
+    $this->setAuthConfig('openid.realm', $realm);
+  }
+
+  /**
+   * If this is provided with the value true, and the authorization request is
+   * granted, the authorization will include any previous authorizations
+   * granted to this user/application combination for other scopes.
+   * @param $include boolean - the URL-space to use.
+   */
+  public function setIncludeGrantedScopes($include)
+  {
+    $this->setAuthConfig(
+        'include_granted_scopes',
+        $include ? "true" : "false"
+    );
+  }
+
+  /**
+   * @return string the base URL to use for API calls
+   */
+  public function getBasePath()
+  {
+    return $this->configuration['base_path'];
+  }
+
+  /**
+   * Set the auth configuration for the current auth class.
+   * @param $key - the key to set
+   * @param $value - the parameter value
+   */
+  private function setAuthConfig($key, $value)
+  {
+    if (!isset($this->configuration['classes'][$this->getAuthClass()])) {
+      $this->configuration['classes'][$this->getAuthClass()] = array();
+    }
+    $this->configuration['classes'][$this->getAuthClass()][$key] = $value;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Exception.php

@@ -0,0 +1,20 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class W3TCG_Google_Exception extends Exception
+{
+}

wp-content/plugins/w3-total-cache/lib/Google/Http/Batch.php

@@ -0,0 +1,139 @@
+<?php
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Chirag Shah <chirags@google.com>
+ */
+class W3TCG_Google_Http_Batch
+{
+  /** @var string Multipart Boundary. */
+  private $boundary;
+
+  /** @var array service requests to be executed. */
+  private $requests = array();
+
+  /** @var W3TCG_Google_Client */
+  private $client;
+
+  private $expected_classes = array();
+
+  private $base_path;
+
+  public function __construct(W3TCG_Google_Client $client, $boundary = false)
+  {
+    $this->client = $client;
+    $this->base_path = $this->client->getBasePath();
+    $this->expected_classes = array();
+    $boundary = (false == $boundary) ? mt_rand() : $boundary;
+    $this->boundary = str_replace('"', '', $boundary);
+  }
+
+  public function add(W3TCG_Google_Http_Request $request, $key = false)
+  {
+    if (false == $key) {
+      $key = mt_rand();
+    }
+
+    $this->requests[$key] = $request;
+  }
+
+  public function execute()
+  {
+    $body = '';
+
+    /** @var W3TCG_Google_Http_Request $req */
+    foreach ($this->requests as $key => $req) {
+      $body .= "--{$this->boundary}\n";
+      $body .= $req->toBatchString($key) . "\n";
+      $this->expected_classes["response-" . $key] = $req->getExpectedClass();
+    }
+
+    $body = rtrim($body);
+    $body .= "\n--{$this->boundary}--";
+
+    $url = $this->base_path . '/batch';
+    $httpRequest = new W3TCG_Google_Http_Request($url, 'POST');
+    $httpRequest->setRequestHeaders(
+        array('Content-Type' => 'multipart/mixed; boundary=' . $this->boundary)
+    );
+
+    $httpRequest->setPostBody($body);
+    $response = $this->client->getIo()->makeRequest($httpRequest);
+
+    return $this->parseResponse($response);
+  }
+
+  public function parseResponse(W3TCG_Google_Http_Request $response)
+  {
+    $contentType = $response->getResponseHeader('content-type');
+    $contentType = explode(';', $contentType);
+    $boundary = false;
+    foreach ($contentType as $part) {
+      $part = (explode('=', $part, 2));
+      if (isset($part[0]) && 'boundary' == trim($part[0])) {
+        $boundary = $part[1];
+      }
+    }
+
+    $body = $response->getResponseBody();
+    if ($body) {
+      $body = str_replace("--$boundary--", "--$boundary", $body);
+      $parts = explode("--$boundary", $body);
+      $responses = array();
+
+      foreach ($parts as $part) {
+        $part = trim($part);
+        if (!empty($part)) {
+          list($metaHeaders, $part) = explode("\r\n\r\n", $part, 2);
+          $metaHeaders = $this->client->getIo()->getHttpResponseHeaders($metaHeaders);
+
+          $status = substr($part, 0, strpos($part, "\n"));
+          $status = explode(" ", $status);
+          $status = $status[1];
+
+          list($partHeaders, $partBody) = $this->client->getIo()->ParseHttpResponse($part, false);
+          $response = new W3TCG_Google_Http_Request("");
+          $response->setResponseHttpCode($status);
+          $response->setResponseHeaders($partHeaders);
+          $response->setResponseBody($partBody);
+
+          // Need content id.
+          $key = $metaHeaders['content-id'];
+
+          if (isset($this->expected_classes[$key]) &&
+              strlen($this->expected_classes[$key]) > 0) {
+            $class = $this->expected_classes[$key];
+            $response->setExpectedClass($class);
+          }
+
+          try {
+            $response = W3TCG_Google_Http_REST::decodeHttpResponse($response);
+            $responses[$key] = $response;
+          } catch (W3TCG_Google_Service_Exception $e) {
+            // Store the exception as the response, so succesful responses
+            // can be processed.
+            $responses[$key] = $e;
+          }
+        }
+      }
+
+      return $responses;
+    }
+
+    return null;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Http/CacheParser.php

@@ -0,0 +1,182 @@
+<?php
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implement the caching directives specified in rfc2616. This
+ * implementation is guided by the guidance offered in rfc2616-sec13.
+ * @author Chirag Shah <chirags@google.com>
+ */
+class W3TCG_Google_Http_CacheParser
+{
+  public static $CACHEABLE_HTTP_METHODS = array('GET', 'HEAD');
+  public static $CACHEABLE_STATUS_CODES = array('200', '203', '300', '301');
+
+  /**
+   * Check if an HTTP request can be cached by a private local cache.
+   *
+   * @static
+   * @param W3TCG_Google_Http_Request $resp
+   * @return bool True if the request is cacheable.
+   * False if the request is uncacheable.
+   */
+  public static function isRequestCacheable(W3TCG_Google_Http_Request $resp)
+  {
+    $method = $resp->getRequestMethod();
+    if (! in_array($method, self::$CACHEABLE_HTTP_METHODS)) {
+      return false;
+    }
+
+    // Don't cache authorized requests/responses.
+    // [rfc2616-14.8] When a shared cache receives a request containing an
+    // Authorization field, it MUST NOT return the corresponding response
+    // as a reply to any other request...
+    if ($resp->getRequestHeader("authorization")) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Check if an HTTP response can be cached by a private local cache.
+   *
+   * @static
+   * @param W3TCG_Google_Http_Request $resp
+   * @return bool True if the response is cacheable.
+   * False if the response is un-cacheable.
+   */
+  public static function isResponseCacheable(W3TCG_Google_Http_Request $resp)
+  {
+    // First, check if the HTTP request was cacheable before inspecting the
+    // HTTP response.
+    if (false == self::isRequestCacheable($resp)) {
+      return false;
+    }
+
+    $code = $resp->getResponseHttpCode();
+    if (! in_array($code, self::$CACHEABLE_STATUS_CODES)) {
+      return false;
+    }
+
+    // The resource is uncacheable if the resource is already expired and
+    // the resource doesn't have an ETag for revalidation.
+    $etag = $resp->getResponseHeader("etag");
+    if (self::isExpired($resp) && $etag == false) {
+      return false;
+    }
+
+    // [rfc2616-14.9.2]  If [no-store is] sent in a response, a cache MUST NOT
+    // store any part of either this response or the request that elicited it.
+    $cacheControl = $resp->getParsedCacheControl();
+    if (isset($cacheControl['no-store'])) {
+      return false;
+    }
+
+    // Pragma: no-cache is an http request directive, but is occasionally
+    // used as a response header incorrectly.
+    $pragma = $resp->getResponseHeader('pragma');
+    if ($pragma == 'no-cache' || strpos($pragma, 'no-cache') !== false) {
+      return false;
+    }
+
+    // [rfc2616-14.44] Vary: * is extremely difficult to cache. "It implies that
+    // a cache cannot determine from the request headers of a subsequent request
+    // whether this response is the appropriate representation."
+    // Given this, we deem responses with the Vary header as uncacheable.
+    $vary = $resp->getResponseHeader('vary');
+    if ($vary) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * @static
+   * @param W3TCG_Google_Http_Request $resp
+   * @return bool True if the HTTP response is considered to be expired.
+   * False if it is considered to be fresh.
+   */
+  public static function isExpired(W3TCG_Google_Http_Request $resp)
+  {
+    // HTTP/1.1 clients and caches MUST treat other invalid date formats,
+    // especially including the value “0”, as in the past.
+    $parsedExpires = false;
+    $responseHeaders = $resp->getResponseHeaders();
+
+    if (isset($responseHeaders['expires'])) {
+      $rawExpires = $responseHeaders['expires'];
+      // Check for a malformed expires header first.
+      if (empty($rawExpires) || (is_numeric($rawExpires) && $rawExpires <= 0)) {
+        return true;
+      }
+
+      // See if we can parse the expires header.
+      $parsedExpires = strtotime($rawExpires);
+      if (false == $parsedExpires || $parsedExpires <= 0) {
+        return true;
+      }
+    }
+
+    // Calculate the freshness of an http response.
+    $freshnessLifetime = false;
+    $cacheControl = $resp->getParsedCacheControl();
+    if (isset($cacheControl['max-age'])) {
+      $freshnessLifetime = $cacheControl['max-age'];
+    }
+
+    $rawDate = $resp->getResponseHeader('date');
+    $parsedDate = strtotime($rawDate);
+
+    if (empty($rawDate) || false == $parsedDate) {
+      // We can't default this to now, as that means future cache reads
+      // will always pass with the logic below, so we will require a
+      // date be injected if not supplied.
+      throw new W3TCG_Google_Exception("All cacheable requests must have creation dates.");
+    }
+
+    if (false == $freshnessLifetime && isset($responseHeaders['expires'])) {
+      $freshnessLifetime = $parsedExpires - $parsedDate;
+    }
+
+    if (false == $freshnessLifetime) {
+      return true;
+    }
+
+    // Calculate the age of an http response.
+    $age = max(0, time() - $parsedDate);
+    if (isset($responseHeaders['age'])) {
+      $age = max($age, strtotime($responseHeaders['age']));
+    }
+
+    return $freshnessLifetime <= $age;
+  }
+
+  /**
+   * Determine if a cache entry should be revalidated with by the origin.
+   *
+   * @param W3TCG_Google_Http_Request $response
+   * @return bool True if the entry is expired, else return false.
+   */
+  public static function mustRevalidate(W3TCG_Google_Http_Request $response)
+  {
+    // [13.3] When a cache has a stale entry that it would like to use as a
+    // response to a client's request, it first has to check with the origin
+    // server to see if its cached entry is still usable.
+    return self::isExpired($response);
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Http/MediaFileUpload.php

@@ -0,0 +1,295 @@
+<?php
+/**
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @author Chirag Shah <chirags@google.com>
+ *
+ */
+class W3TCG_Google_Http_MediaFileUpload
+{
+  const UPLOAD_MEDIA_TYPE = 'media';
+  const UPLOAD_MULTIPART_TYPE = 'multipart';
+  const UPLOAD_RESUMABLE_TYPE = 'resumable';
+
+  /** @var string $mimeType */
+  private $mimeType;
+
+  /** @var string $data */
+  private $data;
+
+  /** @var bool $resumable */
+  private $resumable;
+
+  /** @var int $chunkSize */
+  private $chunkSize;
+
+  /** @var int $size */
+  private $size;
+
+  /** @var string $resumeUri */
+  private $resumeUri;
+
+  /** @var int $progress */
+  private $progress;
+
+  /** @var W3TCG_Google_Client */
+  private $client;
+
+  /** @var W3TCG_Google_Http_Request */
+  private $request;
+
+  /** @var string */
+  private $boundary;
+
+  /**
+   * Result code from last HTTP call
+   * @var int
+   */
+  private $httpResultCode;
+
+  /**
+   * @param $mimeType string
+   * @param $data string The bytes you want to upload.
+   * @param $resumable bool
+   * @param bool $chunkSize File will be uploaded in chunks of this many bytes.
+   * only used if resumable=True
+   */
+  public function __construct(
+      W3TCG_Google_Client $client,
+      W3TCG_Google_Http_Request $request,
+      $mimeType,
+      $data,
+      $resumable = false,
+      $chunkSize = false,
+      $boundary = false
+  ) {
+    $this->client = $client;
+    $this->request = $request;
+    $this->mimeType = $mimeType;
+    $this->data = $data;
+    $this->size = strlen($this->data);
+    $this->resumable = $resumable;
+    if (!$chunkSize) {
+      $chunkSize = 256 * 1024;
+    }
+    $this->chunkSize = $chunkSize;
+    $this->progress = 0;
+    $this->boundary = $boundary;
+
+    // Process Media Request
+    $this->process();
+  }
+
+  /**
+   * Set the size of the file that is being uploaded.
+   * @param $size - int file size in bytes
+   */
+  public function setFileSize($size)
+  {
+    $this->size = $size;
+  }
+
+  /**
+   * Return the progress on the upload
+   * @return int progress in bytes uploaded.
+   */
+  public function getProgress()
+  {
+    return $this->progress;
+  }
+
+  /**
+   * Return the HTTP result code from the last call made.
+   * @return int code
+   */
+  public function getHttpResultCode()
+  {
+    return $this->httpResultCode;
+  }
+
+  /**
+   * Send the next part of the file to upload.
+   * @param [$chunk] the next set of bytes to send. If false will used $data passed
+   * at construct time.
+   */
+  public function nextChunk($chunk = false)
+  {
+    if (false == $this->resumeUri) {
+      $this->resumeUri = $this->getResumeUri();
+    }
+
+    if (false == $chunk) {
+      $chunk = substr($this->data, $this->progress, $this->chunkSize);
+    }
+
+    $lastBytePos = $this->progress + strlen($chunk) - 1;
+    $headers = array(
+      'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
+      'content-type' => $this->request->getRequestHeader('content-type'),
+      'content-length' => $this->chunkSize,
+      'expect' => '',
+    );
+
+    $httpRequest = new W3TCG_Google_Http_Request(
+        $this->resumeUri,
+        'PUT',
+        $headers,
+        $chunk
+    );
+
+    if ($this->client->getClassConfig("W3TCG_Google_Http_Request", "enable_gzip_for_uploads")) {
+      $httpRequest->enableGzip();
+    } else {
+      $httpRequest->disableGzip();
+    }
+
+    $response = $this->client->getIo()->makeRequest($httpRequest);
+    $response->setExpectedClass($this->request->getExpectedClass());
+    $code = $response->getResponseHttpCode();
+    $this->httpResultCode = $code;
+
+    if (308 == $code) {
+      // Track the amount uploaded.
+      $range = explode('-', $response->getResponseHeader('range'));
+      $this->progress = $range[1] + 1;
+
+      // Allow for changing upload URLs.
+      $location = $response->getResponseHeader('location');
+      if ($location) {
+        $this->resumeUri = $location;
+      }
+
+      // No problems, but upload not complete.
+      return false;
+    } else {
+      return W3TCG_Google_Http_REST::decodeHttpResponse($response);
+    }
+  }
+
+  /**
+   * @param $meta
+   * @param $params
+   * @return array|bool
+   * @visible for testing
+   */
+  private function process()
+  {
+    $postBody = false;
+    $contentType = false;
+
+    $meta = $this->request->getPostBody();
+    $meta = is_string($meta) ? json_decode($meta, true) : $meta;
+
+    $uploadType = $this->getUploadType($meta);
+    $this->request->setQueryParam('uploadType', $uploadType);
+    $this->transformToUploadUrl();
+    $mimeType = $this->mimeType ?
+        $this->mimeType :
+        $this->request->getRequestHeader('content-type');
+
+    if (self::UPLOAD_RESUMABLE_TYPE == $uploadType) {
+      $contentType = $mimeType;
+      $postBody = is_string($meta) ? $meta : json_encode($meta);
+    } else if (self::UPLOAD_MEDIA_TYPE == $uploadType) {
+      $contentType = $mimeType;
+      $postBody = $this->data;
+    } else if (self::UPLOAD_MULTIPART_TYPE == $uploadType) {
+      // This is a multipart/related upload.
+      $boundary = $this->boundary ? $this->boundary : mt_rand();
+      $boundary = str_replace('"', '', $boundary);
+      $contentType = 'multipart/related; boundary=' . $boundary;
+      $related = "--$boundary\r\n";
+      $related .= "Content-Type: application/json; charset=UTF-8\r\n";
+      $related .= "\r\n" . json_encode($meta) . "\r\n";
+      $related .= "--$boundary\r\n";
+      $related .= "Content-Type: $mimeType\r\n";
+      $related .= "Content-Transfer-Encoding: base64\r\n";
+      $related .= "\r\n" . base64_encode($this->data) . "\r\n";
+      $related .= "--$boundary--";
+      $postBody = $related;
+    }
+
+    $this->request->setPostBody($postBody);
+
+    if (isset($contentType) && $contentType) {
+      $contentTypeHeader['content-type'] = $contentType;
+      $this->request->setRequestHeaders($contentTypeHeader);
+    }
+  }
+
+  private function transformToUploadUrl()
+  {
+    $base = $this->request->getBaseComponent();
+    $this->request->setBaseComponent($base . '/upload');
+  }
+
+  /**
+   * Valid upload types:
+   * - resumable (UPLOAD_RESUMABLE_TYPE)
+   * - media (UPLOAD_MEDIA_TYPE)
+   * - multipart (UPLOAD_MULTIPART_TYPE)
+   * @param $meta
+   * @return string
+   * @visible for testing
+   */
+  public function getUploadType($meta)
+  {
+    if ($this->resumable) {
+      return self::UPLOAD_RESUMABLE_TYPE;
+    }
+
+    if (false == $meta && $this->data) {
+      return self::UPLOAD_MEDIA_TYPE;
+    }
+
+    return self::UPLOAD_MULTIPART_TYPE;
+  }
+
+  private function getResumeUri()
+  {
+    $result = null;
+    $body = $this->request->getPostBody();
+    if ($body) {
+      $headers = array(
+        'content-type' => 'application/json; charset=UTF-8',
+        'content-length' => W3TCG_Google_Utils::getStrLen($body),
+        'x-upload-content-type' => $this->mimeType,
+        'x-upload-content-length' => $this->size,
+        'expect' => '',
+      );
+      $this->request->setRequestHeaders($headers);
+    }
+
+    $response = $this->client->getIo()->makeRequest($this->request);
+    $location = $response->getResponseHeader('location');
+    $code = $response->getResponseHttpCode();
+
+    if (200 == $code && true == $location) {
+      return $location;
+    }
+    $message = $code;
+    $body = @json_decode($response->getResponseBody());
+    if (!empty( $body->error->errors ) ) {
+      $message .= ': ';
+      foreach ($body->error->errors as $error) {
+        $message .= "{$error->domain}, {$error->message};";
+      }
+      $message = rtrim($message, ';');
+    }
+    throw new W3TCG_Google_Exception("Failed to start the resumable upload (HTTP {$message})");
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Http/REST.php

@@ -0,0 +1,134 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class implements the RESTful transport of apiServiceRequest()'s
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ * @author Chirag Shah <chirags@google.com>
+ */
+class W3TCG_Google_Http_REST
+{
+  /**
+   * Executes a W3TCG_Google_Http_Request
+   *
+   * @param W3TCG_Google_Client $client
+   * @param W3TCG_Google_Http_Request $req
+   * @return array decoded result
+   * @throws W3TCG_Google_Service_Exception on server side error (ie: not authenticated,
+   *  invalid or malformed post body, invalid url)
+   */
+  public static function execute(W3TCG_Google_Client $client, W3TCG_Google_Http_Request $req)
+  {
+    $httpRequest = $client->getIo()->makeRequest($req);
+    $httpRequest->setExpectedClass($req->getExpectedClass());
+    return self::decodeHttpResponse($httpRequest);
+  }
+
+  /**
+   * Decode an HTTP Response.
+   * @static
+   * @throws W3TCG_Google_Service_Exception
+   * @param W3TCG_Google_Http_Request $response The http response to be decoded.
+   * @return mixed|null
+   */
+  public static function decodeHttpResponse($response)
+  {
+    $code = $response->getResponseHttpCode();
+    $body = $response->getResponseBody();
+    $decoded = null;
+
+    if ((intVal($code)) >= 300) {
+      $decoded = json_decode($body, true);
+      $err = 'Error calling ' . $response->getRequestMethod() . ' ' . $response->getUrl();
+      if (isset($decoded['error']) &&
+          isset($decoded['error']['message'])  &&
+          isset($decoded['error']['code'])) {
+        // if we're getting a json encoded error definition, use that instead of the raw response
+        // body for improved readability
+        $err .= ": ({$decoded['error']['code']}) {$decoded['error']['message']}";
+      } else {
+        $err .= ": ($code) $body";
+      }
+
+      $errors = null;
+      // Specific check for APIs which don't return error details, such as Blogger.
+      if (isset($decoded['error']) && isset($decoded['error']['errors'])) {
+        $errors = $decoded['error']['errors'];
+      }
+
+      throw new W3TCG_Google_Service_Exception($err, $code, null, $errors);
+    }
+
+    // Only attempt to decode the response, if the response code wasn't (204) 'no content'
+    if ($code != '204') {
+      $decoded = json_decode($body, true);
+      if ($decoded === null || $decoded === "") {
+        throw new W3TCG_Google_Service_Exception("Invalid json in service response: $body");
+      }
+
+      if ($response->getExpectedClass()) {
+        $class = $response->getExpectedClass();
+        $decoded = new $class($decoded);
+      }
+    }
+    return $decoded;
+  }
+
+  /**
+   * Parse/expand request parameters and create a fully qualified
+   * request uri.
+   * @static
+   * @param string $servicePath
+   * @param string $restPath
+   * @param array $params
+   * @return string $requestUrl
+   */
+  public static function createRequestUri($servicePath, $restPath, $params)
+  {
+    $requestUrl = $servicePath . $restPath;
+    $uriTemplateVars = array();
+    $queryVars = array();
+    foreach ($params as $paramName => $paramSpec) {
+      if ($paramSpec['type'] == 'boolean') {
+        $paramSpec['value'] = ($paramSpec['value']) ? 'true' : 'false';
+      }
+      if ($paramSpec['location'] == 'path') {
+        $uriTemplateVars[$paramName] = $paramSpec['value'];
+      } else if ($paramSpec['location'] == 'query') {
+        if (isset($paramSpec['repeated']) && is_array($paramSpec['value'])) {
+          foreach ($paramSpec['value'] as $value) {
+            $queryVars[] = $paramName . '=' . rawurlencode($value);
+          }
+        } else {
+          $queryVars[] = $paramName . '=' . rawurlencode($paramSpec['value']);
+        }
+      }
+    }
+
+    if (count($uriTemplateVars)) {
+      $uriTemplateParser = new W3TCG_Google_Utils_URITemplate();
+      $requestUrl = $uriTemplateParser->parse($requestUrl, $uriTemplateVars);
+    }
+
+    if (count($queryVars)) {
+      $requestUrl .= '?' . implode($queryVars, '&');
+    }
+
+    return $requestUrl;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Http/Request.php

@@ -0,0 +1,474 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * HTTP Request to be executed by IO classes. Upon execution, the
+ * responseHttpCode, responseHeaders and responseBody will be filled in.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ * @author Chirag Shah <chirags@google.com>
+ *
+ */
+class W3TCG_Google_Http_Request
+{
+  const GZIP_UA = " (gzip)";
+
+  private $batchHeaders = array(
+    'Content-Type' => 'application/http',
+    'Content-Transfer-Encoding' => 'binary',
+    'MIME-Version' => '1.0',
+  );
+
+  protected $queryParams;
+  protected $requestMethod;
+  protected $requestHeaders;
+  protected $baseComponent = null;
+  protected $path;
+  protected $postBody;
+  protected $userAgent;
+  protected $canGzip = null;
+
+  protected $responseHttpCode;
+  protected $responseHeaders;
+  protected $responseBody;
+  
+  protected $expectedClass;
+
+  public $accessKey;
+
+  public function __construct(
+      $url,
+      $method = 'GET',
+      $headers = array(),
+      $postBody = null
+  ) {
+    $this->setUrl($url);
+    $this->setRequestMethod($method);
+    $this->setRequestHeaders($headers);
+    $this->setPostBody($postBody);
+  }
+
+  /**
+   * Misc function that returns the base url component of the $url
+   * used by the OAuth signing class to calculate the base string
+   * @return string The base url component of the $url.
+   */
+  public function getBaseComponent()
+  {
+    return $this->baseComponent;
+  }
+  
+  /**
+   * Set the base URL that path and query parameters will be added to.
+   * @param $baseComponent string
+   */
+  public function setBaseComponent($baseComponent)
+  {
+    $this->baseComponent = $baseComponent;
+  }
+  
+  /**
+   * Enable support for gzipped responses with this request.
+   */
+  public function enableGzip()
+  {
+    $this->setRequestHeaders(array("Accept-Encoding" => "gzip"));
+    $this->canGzip = true;
+    $this->setUserAgent($this->userAgent);
+  }
+  
+  /**
+   * Disable support for gzip responses with this request.
+   */
+  public function disableGzip()
+  {
+    if (
+        isset($this->requestHeaders['accept-encoding']) &&
+        $this->requestHeaders['accept-encoding'] == "gzip"
+    ) {
+      unset($this->requestHeaders['accept-encoding']);
+    }
+    $this->canGzip = false;
+    $this->userAgent = str_replace(self::GZIP_UA, "", $this->userAgent);
+  }
+  
+  /**
+   * Can this request accept a gzip response?
+   * @return bool
+   */
+  public function canGzip()
+  {
+    return $this->canGzip;
+  }
+
+  /**
+   * Misc function that returns an array of the query parameters of the current
+   * url used by the OAuth signing class to calculate the signature
+   * @return array Query parameters in the query string.
+   */
+  public function getQueryParams()
+  {
+    return $this->queryParams;
+  }
+
+  /** 
+   * Set a new query parameter.
+   * @param $key - string to set, does not need to be URL encoded
+   * @param $value - string to set, does not need to be URL encoded
+   */
+  public function setQueryParam($key, $value)
+  {
+    $this->queryParams[$key] = $value;
+  }
+
+  /**
+   * @return string HTTP Response Code.
+   */
+  public function getResponseHttpCode()
+  {
+    return (int) $this->responseHttpCode;
+  }
+
+  /**
+   * @param int $responseHttpCode HTTP Response Code.
+   */
+  public function setResponseHttpCode($responseHttpCode)
+  {
+    $this->responseHttpCode = $responseHttpCode;
+  }
+
+  /**
+   * @return $responseHeaders (array) HTTP Response Headers.
+   */
+  public function getResponseHeaders()
+  {
+    return $this->responseHeaders;
+  }
+
+  /**
+   * @return string HTTP Response Body
+   */
+  public function getResponseBody()
+  {
+    return $this->responseBody;
+  }
+  
+  /**
+   * Set the class the response to this request should expect.
+   *
+   * @param $class string the class name
+   */
+  public function setExpectedClass($class)
+  {
+    $this->expectedClass = $class;
+  }
+  
+  /**
+   * Retrieve the expected class the response should expect.
+   * @return string class name
+   */
+  public function getExpectedClass()
+  {
+    return $this->expectedClass;
+  }
+
+  /**
+   * @param array $headers The HTTP response headers
+   * to be normalized.
+   */
+  public function setResponseHeaders($headers)
+  {
+    $headers = W3TCG_Google_Utils::normalize($headers);
+    if ($this->responseHeaders) {
+      $headers = array_merge($this->responseHeaders, $headers);
+    }
+
+    $this->responseHeaders = $headers;
+  }
+
+  /**
+   * @param string $key
+   * @return array|boolean Returns the requested HTTP header or
+   * false if unavailable.
+   */
+  public function getResponseHeader($key)
+  {
+    return isset($this->responseHeaders[$key])
+        ? $this->responseHeaders[$key]
+        : false;
+  }
+
+  /**
+   * @param string $responseBody The HTTP response body.
+   */
+  public function setResponseBody($responseBody)
+  {
+    $this->responseBody = $responseBody;
+  }
+
+  /**
+   * @return string $url The request URL.
+   */
+  public function getUrl()
+  {
+    return $this->baseComponent . $this->path .
+        (count($this->queryParams) ?
+            "?" . $this->buildQuery($this->queryParams) :
+            '');
+  }
+
+  /**
+   * @return string $method HTTP Request Method.
+   */
+  public function getRequestMethod()
+  {
+    return $this->requestMethod;
+  }
+
+  /**
+   * @return array $headers HTTP Request Headers.
+   */
+  public function getRequestHeaders()
+  {
+    return $this->requestHeaders;
+  }
+
+  /**
+   * @param string $key
+   * @return array|boolean Returns the requested HTTP header or
+   * false if unavailable.
+   */
+  public function getRequestHeader($key)
+  {
+    return isset($this->requestHeaders[$key])
+        ? $this->requestHeaders[$key]
+        : false;
+  }
+
+  /**
+   * @return string $postBody HTTP Request Body.
+   */
+  public function getPostBody()
+  {
+    return $this->postBody;
+  }
+
+  /**
+   * @param string $url the url to set
+   */
+  public function setUrl($url)
+  {
+    if (substr($url, 0, 4) != 'http') {
+      // Force the path become relative.
+      if (substr($url, 0, 1) !== '/') {
+        $url = '/' . $url;
+      }
+    }
+    $parts = parse_url($url);
+    if (isset($parts['host'])) {
+      $this->baseComponent = sprintf(
+          "%s%s%s",
+          isset($parts['scheme']) ? $parts['scheme'] . "://" : '',
+          isset($parts['host']) ? $parts['host'] : '',
+          isset($parts['port']) ? ":" . $parts['port'] : ''
+      );
+    }
+    $this->path = isset($parts['path']) ? $parts['path'] : '';
+    $this->queryParams = array();
+    if (isset($parts['query'])) {
+      $this->queryParams = $this->parseQuery($parts['query']);
+    }
+  }
+
+  /**
+   * @param string $method Set he HTTP Method and normalize
+   * it to upper-case, as required by HTTP.
+   *
+   */
+  public function setRequestMethod($method)
+  {
+    $this->requestMethod = strtoupper($method);
+  }
+
+  /**
+   * @param array $headers The HTTP request headers
+   * to be set and normalized.
+   */
+  public function setRequestHeaders($headers)
+  {
+    $headers = W3TCG_Google_Utils::normalize($headers);
+    if ($this->requestHeaders) {
+      $headers = array_merge($this->requestHeaders, $headers);
+    }
+    $this->requestHeaders = $headers;
+  }
+
+  /**
+   * @param string $postBody the postBody to set
+   */
+  public function setPostBody($postBody)
+  {
+    $this->postBody = $postBody;
+  }
+
+  /**
+   * Set the User-Agent Header.
+   * @param string $userAgent The User-Agent.
+   */
+  public function setUserAgent($userAgent)
+  {
+    $this->userAgent = $userAgent;
+    if ($this->canGzip) {
+      $this->userAgent = $userAgent . self::GZIP_UA;
+    }
+  }
+
+  /**
+   * @return string The User-Agent.
+   */
+  public function getUserAgent()
+  {
+    return $this->userAgent;
+  }
+
+  /**
+   * Returns a cache key depending on if this was an OAuth signed request
+   * in which case it will use the non-signed url and access key to make this
+   * cache key unique per authenticated user, else use the plain request url
+   * @return string The md5 hash of the request cache key.
+   */
+  public function getCacheKey()
+  {
+    $key = $this->getUrl();
+
+    if (isset($this->accessKey)) {
+      $key .= $this->accessKey;
+    }
+
+    if (isset($this->requestHeaders['authorization'])) {
+      $key .= $this->requestHeaders['authorization'];
+    }
+
+    return md5($key);
+  }
+
+  public function getParsedCacheControl()
+  {
+    $parsed = array();
+    $rawCacheControl = $this->getResponseHeader('cache-control');
+    if ($rawCacheControl) {
+      $rawCacheControl = str_replace(', ', '&', $rawCacheControl);
+      parse_str($rawCacheControl, $parsed);
+    }
+
+    return $parsed;
+  }
+
+  /**
+   * @param string $id
+   * @return string A string representation of the HTTP Request.
+   */
+  public function toBatchString($id)
+  {
+    $str = '';
+    $path = parse_url($this->getUrl(), PHP_URL_PATH) . "?" .
+        http_build_query($this->queryParams);
+    $str .= $this->getRequestMethod() . ' ' . $path . " HTTP/1.1\n";
+
+    foreach ($this->getRequestHeaders() as $key => $val) {
+      $str .= $key . ': ' . $val . "\n";
+    }
+
+    if ($this->getPostBody()) {
+      $str .= "\n";
+      $str .= $this->getPostBody();
+    }
+    
+    $headers = '';
+    foreach ($this->batchHeaders as $key => $val) {
+      $headers .= $key . ': ' . $val . "\n";
+    }
+
+    $headers .= "Content-ID: $id\n";
+    $str = $headers . "\n" . $str;
+
+    return $str;
+  }
+  
+  /**
+   * Our own version of parse_str that allows for multiple variables
+   * with the same name. 
+   * @param $string - the query string to parse
+   */
+  private function parseQuery($string)
+  {
+    $return = array();
+    $parts = explode("&", $string);
+    foreach ($parts as $part) {
+      list($key, $value) = explode('=', $part, 2);
+      $value = urldecode($value);
+      if (isset($return[$key])) {
+        if (!is_array($return[$key])) {
+          $return[$key] = array($return[$key]);
+        }
+        $return[$key][] = $value;
+      } else {
+        $return[$key] = $value;
+      }
+    }
+    return $return;
+  }
+  
+  /**
+   * A version of build query that allows for multiple
+   * duplicate keys. 
+   * @param $parts array of key value pairs
+   */
+  private function buildQuery($parts)
+  {
+    $return = array();
+    foreach ($parts as $key => $value) {
+      if (is_array($value)) {
+        foreach ($value as $v) {
+          $return[] = urlencode($key) . "=" . urlencode($v);
+        }
+      } else {
+        $return[] = urlencode($key) . "=" . urlencode($value);
+      }
+    }
+    return implode('&', $return);
+  }
+  
+  /** 
+   * If we're POSTing and have no body to send, we can send the query
+   * parameters in there, which avoids length issues with longer query
+   * params.
+   */
+  public function maybeMoveParametersToBody()
+  {
+    if ($this->getRequestMethod() == "POST" && empty($this->postBody)) {
+      $this->setRequestHeaders(
+          array(
+            "content-type" =>
+                "application/x-www-form-urlencoded; charset=UTF-8"
+          )
+      );
+      $this->setPostBody($this->buildQuery($this->queryParams));
+      $this->queryParams = array();
+    }
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/IO/Abstract.php

@@ -0,0 +1,327 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Abstract IO base class
+ */
+
+abstract class W3TCG_Google_IO_Abstract
+{
+  const UNKNOWN_CODE = 0;
+  const FORM_URLENCODED = 'application/x-www-form-urlencoded';
+  private static $CONNECTION_ESTABLISHED_HEADERS = array(
+    "HTTP/1.0 200 Connection established\r\n\r\n",
+    "HTTP/1.1 200 Connection established\r\n\r\n",
+  );
+  private static $ENTITY_HTTP_METHODS = array("POST" => null, "PUT" => null);
+
+  /** @var W3TCG_Google_Client */
+  protected $client;
+
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    $this->client = $client;
+    $timeout = $client->getClassConfig('W3TCG_Google_IO_Abstract', 'request_timeout_seconds');
+    if ($timeout > 0) {
+      $this->setTimeout($timeout);
+    }
+  }
+
+  /**
+   * Executes a W3TCG_Google_Http_Request and returns the resulting populated W3TCG_Google_Http_Request
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request $request
+   */
+  abstract public function executeRequest(W3TCG_Google_Http_Request $request);
+
+  /**
+   * Set options that update the transport implementation's behavior.
+   * @param $options
+   */
+  abstract public function setOptions($options);
+  
+  /**
+   * Set the maximum request time in seconds.
+   * @param $timeout in seconds
+   */
+  abstract public function setTimeout($timeout);
+  
+  /**
+   * Get the maximum request time in seconds.
+   * @return timeout in seconds
+   */
+  abstract public function getTimeout();
+
+  /**
+   * Test for the presence of a cURL header processing bug
+   *
+   * The cURL bug was present in versions prior to 7.30.0 and caused the header
+   * length to be miscalculated when a "Connection established" header added by
+   * some proxies was present.
+   *
+   * @return boolean
+   */
+  abstract protected function needsQuirk();
+
+  /**
+   * @visible for testing.
+   * Cache the response to an HTTP request if it is cacheable.
+   * @param W3TCG_Google_Http_Request $request
+   * @return bool Returns true if the insertion was successful.
+   * Otherwise, return false.
+   */
+  public function setCachedRequest(W3TCG_Google_Http_Request $request)
+  {
+    // Determine if the request is cacheable.
+    if (W3TCG_Google_Http_CacheParser::isResponseCacheable($request)) {
+      $this->client->getCache()->set($request->getCacheKey(), $request);
+      return true;
+    }
+
+    return false;
+  }
+  
+  /**
+   * Execute an HTTP Request
+   *
+   * @param W3TCG_Google_HttpRequest $request the http request to be executed
+   * @return W3TCG_Google_HttpRequest http request with the response http code,
+   * response headers and response body filled in
+   * @throws W3TCG_Google_IO_Exception on curl or IO error
+   */
+  public function makeRequest(W3TCG_Google_Http_Request $request)
+  {
+    // First, check to see if we have a valid cached version.
+    $cached = $this->getCachedRequest($request);
+    if ($cached !== false && $cached instanceof W3TCG_Google_Http_Request) {
+      if (!$this->checkMustRevalidateCachedRequest($cached, $request)) {
+        return $cached;
+      }
+    }
+
+    if (array_key_exists($request->getRequestMethod(), self::$ENTITY_HTTP_METHODS)) {
+      $request = $this->processEntityRequest($request);
+    }
+
+    list($responseData, $responseHeaders, $respHttpCode) = $this->executeRequest($request);
+
+    if ($respHttpCode == 304 && $cached) {
+      // If the server responded NOT_MODIFIED, return the cached request.
+      $this->updateCachedRequest($cached, $responseHeaders);
+      return $cached;
+    }
+
+    if (!isset($responseHeaders['Date']) && !isset($responseHeaders['date'])) {
+      $responseHeaders['Date'] = date("r");
+    }
+
+    $request->setResponseHttpCode($respHttpCode);
+    $request->setResponseHeaders($responseHeaders);
+    $request->setResponseBody($responseData);
+    // Store the request in cache (the function checks to see if the request
+    // can actually be cached)
+    $this->setCachedRequest($request);
+    return $request;
+  }
+
+  /**
+   * @visible for testing.
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request|bool Returns the cached object or
+   * false if the operation was unsuccessful.
+   */
+  public function getCachedRequest(W3TCG_Google_Http_Request $request)
+  {
+    if (false === W3TCG_Google_Http_CacheParser::isRequestCacheable($request)) {
+      return false;
+    }
+
+    return $this->client->getCache()->get($request->getCacheKey());
+  }
+
+  /**
+   * @visible for testing
+   * Process an http request that contains an enclosed entity.
+   * @param W3TCG_Google_Http_Request $request
+   * @return W3TCG_Google_Http_Request Processed request with the enclosed entity.
+   */
+  public function processEntityRequest(W3TCG_Google_Http_Request $request)
+  {
+    $postBody = $request->getPostBody();
+    $contentType = $request->getRequestHeader("content-type");
+
+    // Set the default content-type as application/x-www-form-urlencoded.
+    if (false == $contentType) {
+      $contentType = self::FORM_URLENCODED;
+      $request->setRequestHeaders(array('content-type' => $contentType));
+    }
+
+    // Force the payload to match the content-type asserted in the header.
+    if ($contentType == self::FORM_URLENCODED && is_array($postBody)) {
+      $postBody = http_build_query($postBody, '', '&');
+      $request->setPostBody($postBody);
+    }
+
+    // Make sure the content-length header is set.
+    if (!$postBody || is_string($postBody)) {
+      $postsLength = strlen($postBody);
+      $request->setRequestHeaders(array('content-length' => $postsLength));
+    }
+
+    return $request;
+  }
+
+  /**
+   * Check if an already cached request must be revalidated, and if so update
+   * the request with the correct ETag headers.
+   * @param W3TCG_Google_Http_Request $cached A previously cached response.
+   * @param W3TCG_Google_Http_Request $request The outbound request.
+   * return bool If the cached object needs to be revalidated, false if it is
+   * still current and can be re-used.
+   */
+  protected function checkMustRevalidateCachedRequest($cached, $request)
+  {
+    if (W3TCG_Google_Http_CacheParser::mustRevalidate($cached)) {
+      $addHeaders = array();
+      if ($cached->getResponseHeader('etag')) {
+        // [13.3.4] If an entity tag has been provided by the origin server,
+        // we must use that entity tag in any cache-conditional request.
+        $addHeaders['If-None-Match'] = $cached->getResponseHeader('etag');
+      } elseif ($cached->getResponseHeader('date')) {
+        $addHeaders['If-Modified-Since'] = $cached->getResponseHeader('date');
+      }
+
+      $request->setRequestHeaders($addHeaders);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * Update a cached request, using the headers from the last response.
+   * @param W3TCG_Google_HttpRequest $cached A previously cached response.
+   * @param mixed Associative array of response headers from the last request.
+   */
+  protected function updateCachedRequest($cached, $responseHeaders)
+  {
+    if (isset($responseHeaders['connection'])) {
+      $hopByHop = array_merge(
+          self::$HOP_BY_HOP,
+          explode(
+              ',',
+              $responseHeaders['connection']
+          )
+      );
+
+      $endToEnd = array();
+      foreach ($hopByHop as $key) {
+        if (isset($responseHeaders[$key])) {
+          $endToEnd[$key] = $responseHeaders[$key];
+        }
+      }
+      $cached->setResponseHeaders($endToEnd);
+    }
+  }
+
+  /**
+   * Used by the IO lib and also the batch processing.
+   *
+   * @param $respData
+   * @param $headerSize
+   * @return array
+   */
+  public function parseHttpResponse($respData, $headerSize)
+  {
+    // check proxy header
+    foreach (self::$CONNECTION_ESTABLISHED_HEADERS as $established_header) {
+      if (stripos($respData, $established_header) !== false) {
+        // existed, remove it
+        $respData = str_ireplace($established_header, '', $respData);
+        // Subtract the proxy header size unless the cURL bug prior to 7.30.0
+        // is present which prevented the proxy header size from being taken into
+        // account.
+        if (!$this->needsQuirk()) {
+          $headerSize -= strlen($established_header);
+        }
+        break;
+      }
+    }
+
+    if ($headerSize) {
+      $responseBody = substr($respData, $headerSize);
+      $responseHeaders = substr($respData, 0, $headerSize);
+    } else {
+      $responseSegments = explode("\r\n\r\n", $respData, 2);
+      $responseHeaders = $responseSegments[0];
+      $responseBody = isset($responseSegments[1]) ? $responseSegments[1] :
+                                                    null;
+    }
+
+    $responseHeaders = $this->getHttpResponseHeaders($responseHeaders);
+    return array($responseHeaders, $responseBody);
+  }
+
+  /**
+   * Parse out headers from raw headers
+   * @param rawHeaders array or string
+   * @return array
+   */
+  public function getHttpResponseHeaders($rawHeaders)
+  {
+    if (is_array($rawHeaders)) {
+      return $this->parseArrayHeaders($rawHeaders);
+    } else {
+      return $this->parseStringHeaders($rawHeaders);
+    }
+  }
+
+  private function parseStringHeaders($rawHeaders)
+  {
+    $headers = array();
+    $responseHeaderLines = explode("\r\n", $rawHeaders);
+    foreach ($responseHeaderLines as $headerLine) {
+      if ($headerLine && strpos($headerLine, ':') !== false) {
+        list($header, $value) = explode(': ', $headerLine, 2);
+        $header = strtolower($header);
+        if (isset($headers[$header])) {
+          $headers[$header] .= "\n" . $value;
+        } else {
+          $headers[$header] = $value;
+        }
+      }
+    }
+    return $headers;
+  }
+
+  private function parseArrayHeaders($rawHeaders)
+  {
+    $header_count = count($rawHeaders);
+    $headers = array();
+
+    for ($i = 0; $i < $header_count; $i++) {
+      $header = $rawHeaders[$i];
+      // Times will have colons in - so we just want the first match.
+      $header_parts = explode(': ', $header, 2);
+      if (count($header_parts) == 2) {
+        $headers[$header_parts[0]] = $header_parts[1];
+      }
+    }
+
+    return $headers;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/IO/Curl.php

@@ -0,0 +1,136 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Curl based implementation of W3TCG_Google_IO.
+ *
+ * @author Stuart Langley <slangley@google.com>
+ */
+
+class W3TCG_Google_IO_Curl extends W3TCG_Google_IO_Abstract
+{
+  // cURL hex representation of version 7.30.0
+  const NO_QUIRK_VERSION = 0x071E00;
+
+  private $options = array();
+  /**
+   * Execute an HTTP Request
+   *
+   * @param W3TCG_Google_HttpRequest $request the http request to be executed
+   * @return W3TCG_Google_HttpRequest http request with the response http code,
+   * response headers and response body filled in
+   * @throws W3TCG_Google_IO_Exception on curl or IO error
+   */
+  public function executeRequest(W3TCG_Google_Http_Request $request)
+  {
+    $curl = curl_init();
+
+    if ($request->getPostBody()) {
+      curl_setopt($curl, CURLOPT_POSTFIELDS, $request->getPostBody());
+    }
+
+    $requestHeaders = $request->getRequestHeaders();
+    if ($requestHeaders && is_array($requestHeaders)) {
+      $curlHeaders = array();
+      foreach ($requestHeaders as $k => $v) {
+        $curlHeaders[] = "$k: $v";
+      }
+      curl_setopt($curl, CURLOPT_HTTPHEADER, $curlHeaders);
+    }
+
+    curl_setopt($curl, CURLOPT_URL, $request->getUrl());
+    
+    curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $request->getRequestMethod());
+    curl_setopt($curl, CURLOPT_USERAGENT, $request->getUserAgent());
+
+    curl_setopt($curl, CURLOPT_FOLLOWLOCATION, false);
+    curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, true);
+    curl_setopt($curl, CURLOPT_SSLVERSION, 1);
+    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
+    curl_setopt($curl, CURLOPT_HEADER, true);
+
+    if ($request->canGzip()) {
+      curl_setopt($curl, CURLOPT_ENCODING, 'gzip,deflate');
+    }
+
+    foreach ($this->options as $key => $var) {
+      curl_setopt($curl, $key, $var);
+    }
+
+    if (!isset($this->options[CURLOPT_CAINFO])) {
+      curl_setopt($curl, CURLOPT_CAINFO, dirname(__FILE__) . '/cacerts.pem');
+    }
+
+    $response = curl_exec($curl);
+    if ($response === false) {
+      throw new W3TCG_Google_IO_Exception(curl_error($curl));
+    }
+    $headerSize = curl_getinfo($curl, CURLINFO_HEADER_SIZE);
+
+    list($responseHeaders, $responseBody) = $this->parseHttpResponse($response, $headerSize);
+
+    $responseCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
+
+    return array($responseBody, $responseHeaders, $responseCode);
+  }
+
+  /**
+   * Set options that update the transport implementation's behavior.
+   * @param $options
+   */
+  public function setOptions($options)
+  {
+    $this->options = $options + $this->options;
+  }
+
+  /**
+   * Set the maximum request time in seconds.
+   * @param $timeout in seconds
+   */
+  public function setTimeout($timeout)
+  {
+    // Since this timeout is really for putting a bound on the time
+    // we'll set them both to the same. If you need to specify a longer
+    // CURLOPT_TIMEOUT, or a tigher CONNECTTIMEOUT, the best thing to
+    // do is use the setOptions method for the values individually.
+    $this->options[CURLOPT_CONNECTTIMEOUT] = $timeout;
+    $this->options[CURLOPT_TIMEOUT] = $timeout;
+  }
+
+  /**
+   * Get the maximum request time in seconds.
+   * @return timeout in seconds
+   */
+  public function getTimeout()
+  {
+    return $this->options[CURLOPT_TIMEOUT];
+  }
+
+  /**
+   * Test for the presence of a cURL header processing bug
+   *
+   * {@inheritDoc}
+   *
+   * @return boolean
+   */
+  protected function needsQuirk()
+  {
+    $ver = curl_version();
+    $versionNum = $ver['version_number'];
+    return $versionNum < W3TCG_Google_IO_Curl::NO_QUIRK_VERSION;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/IO/Exception.php

@@ -0,0 +1,20 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class W3TCG_Google_IO_Exception extends W3TCG_Google_Exception
+{
+}

wp-content/plugins/w3-total-cache/lib/Google/IO/Stream.php

@@ -0,0 +1,209 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Http Streams based implementation of W3TCG_Google_IO.
+ *
+ * @author Stuart Langley <slangley@google.com>
+ */
+
+class W3TCG_Google_IO_Stream extends W3TCG_Google_IO_Abstract
+{
+  const TIMEOUT = "timeout";
+  const ZLIB = "compress.zlib://";
+  private $options = array();
+  private $trappedErrorNumber;
+  private $trappedErrorString;
+
+  private static $DEFAULT_HTTP_CONTEXT = array(
+    "follow_location" => 0,
+    "ignore_errors" => 1,
+  );
+
+  private static $DEFAULT_SSL_CONTEXT = array(
+    "verify_peer" => true,
+  );
+
+  /**
+   * Execute an HTTP Request
+   *
+   * @param W3TCG_Google_HttpRequest $request the http request to be executed
+   * @return W3TCG_Google_HttpRequest http request with the response http code,
+   * response headers and response body filled in
+   * @throws W3TCG_Google_IO_Exception on curl or IO error
+   */
+  public function executeRequest(W3TCG_Google_Http_Request $request)
+  {
+    $default_options = stream_context_get_options(stream_context_get_default());
+
+    $requestHttpContext = array_key_exists('http', $default_options) ?
+        $default_options['http'] : array();
+
+    if ($request->getPostBody()) {
+      $requestHttpContext["content"] = $request->getPostBody();
+    }
+
+    $requestHeaders = $request->getRequestHeaders();
+    if ($requestHeaders && is_array($requestHeaders)) {
+      $headers = "";
+      foreach ($requestHeaders as $k => $v) {
+        $headers .= "$k: $v\r\n";
+      }
+      $requestHttpContext["header"] = $headers;
+    }
+
+    $requestHttpContext["method"] = $request->getRequestMethod();
+    $requestHttpContext["user_agent"] = $request->getUserAgent();
+
+    $requestSslContext = array_key_exists('ssl', $default_options) ?
+        $default_options['ssl'] : array();
+
+    if (!array_key_exists("cafile", $requestSslContext)) {
+      $requestSslContext["cafile"] = dirname(__FILE__) . '/cacerts.pem';
+    }
+
+    $options = array(
+        "http" => array_merge(
+            self::$DEFAULT_HTTP_CONTEXT,
+            $requestHttpContext
+        ),
+        "ssl" => array_merge(
+            self::$DEFAULT_SSL_CONTEXT,
+            $requestSslContext
+        )
+    );
+
+    $context = stream_context_create($options);
+
+    $url = $request->getUrl();
+
+    if ($request->canGzip()) {
+      $url = self::ZLIB . $url;
+    }
+
+    // We are trapping any thrown errors in this method only and
+    // throwing an exception.
+    $this->trappedErrorNumber = null;
+    $this->trappedErrorString = null;
+
+    // START - error trap.
+    set_error_handler(array($this, 'trapError'));
+    $fh = fopen($url, 'r', false, $context);
+    restore_error_handler();
+    // END - error trap.
+
+    if ($this->trappedErrorNumber) {
+      throw new W3TCG_Google_IO_Exception(
+          sprintf(
+              "HTTP Error: Unable to connect: '%s'",
+              $this->trappedErrorString
+          ),
+          $this->trappedErrorNumber
+      );
+    }
+
+    $response_data = false;
+    $respHttpCode = self::UNKNOWN_CODE;
+    if ($fh) {
+      if (isset($this->options[self::TIMEOUT])) {
+        stream_set_timeout($fh, $this->options[self::TIMEOUT]);
+      }
+
+      $response_data = stream_get_contents($fh);
+      fclose($fh);
+
+      $respHttpCode = $this->getHttpResponseCode($http_response_header);
+    }
+
+    if (false === $response_data) {
+      throw new W3TCG_Google_IO_Exception(
+          sprintf(
+              "HTTP Error: Unable to connect: '%s'",
+              $respHttpCode
+          ),
+          $respHttpCode
+      );
+    }
+
+    $responseHeaders = $this->getHttpResponseHeaders($http_response_header);
+
+    return array($response_data, $responseHeaders, $respHttpCode);
+  }
+
+  /**
+   * Set options that update the transport implementation's behavior.
+   * @param $options
+   */
+  public function setOptions($options)
+  {
+    $this->options = $options + $this->options;
+  }
+
+  /**
+   * Method to handle errors, used for error handling around
+   * stream connection methods.
+   */
+  public function trapError($errno, $errstr)
+  {
+    $this->trappedErrorNumber = $errno;
+    $this->trappedErrorString = $errstr;
+  }
+
+  /**
+   * Set the maximum request time in seconds.
+   * @param $timeout in seconds
+   */
+  public function setTimeout($timeout)
+  {
+    $this->options[self::TIMEOUT] = $timeout;
+  }
+
+  /**
+   * Get the maximum request time in seconds.
+   * @return timeout in seconds
+   */
+  public function getTimeout()
+  {
+    return $this->options[self::TIMEOUT];
+  }
+
+  /**
+   * Test for the presence of a cURL header processing bug
+   *
+   * {@inheritDoc}
+   *
+   * @return boolean
+   */
+  protected function needsQuirk()
+  {
+    return false;
+  }
+
+  protected function getHttpResponseCode($response_headers)
+  {
+    $header_count = count($response_headers);
+
+    for ($i = 0; $i < $header_count; $i++) {
+      $header = $response_headers[$i];
+      if (strncasecmp("HTTP", $header, strlen("HTTP")) == 0) {
+        $response = explode(' ', $header);
+        return $response[1];
+      }
+    }
+    return self::UNKNOWN_CODE;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Model.php

@@ -0,0 +1,281 @@
+<?php
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * This class defines attributes, valid values, and usage which is generated
+ * from a given json schema.
+ * http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5
+ *
+ * @author Chirag Shah <chirags@google.com>
+ *
+ */
+class W3TCG_Google_Model implements ArrayAccess
+{
+  protected $internal_gapi_mappings = array();
+  protected $modelData = array();
+  protected $processed = array();
+
+  /**
+   * Polymorphic - accepts a variable number of arguments dependent
+   * on the type of the model subclass.
+   */
+  final public function __construct()
+  {
+    if (func_num_args() == 1 && is_array(func_get_arg(0))) {
+      // Initialize the model with the array's contents.
+      $array = func_get_arg(0);
+      $this->mapTypes($array);
+    }
+    $this->gapiInit();
+  }
+
+  /**
+   * Getter that handles passthrough access to the data array, and lazy object creation.
+   * @param string $key Property name.
+   * @return mixed The value if any, or null.
+   */
+  public function __get($key)
+  {
+    $keyTypeName = $this->keyType($key);
+    $keyDataType = $this->dataType($key);
+    if (isset($this->$keyTypeName) && !isset($this->processed[$key])) {
+      if (isset($this->modelData[$key])) {
+        $val = $this->modelData[$key];
+      } else if (isset($this->$keyDataType) &&
+          ($this->$keyDataType == 'array' || $this->$keyDataType == 'map')) {
+        $val = array();
+      } else {
+        $val = null;
+      }
+
+      if ($this->isAssociativeArray($val)) {
+        if (isset($this->$keyDataType) && 'map' == $this->$keyDataType) {
+          foreach ($val as $arrayKey => $arrayItem) {
+              $this->modelData[$key][$arrayKey] =
+                $this->createObjectFromName($keyTypeName, $arrayItem);
+          }
+        } else {
+          $this->modelData[$key] = $this->createObjectFromName($keyTypeName, $val);
+        }
+      } else if (is_array($val)) {
+        $arrayObject = array();
+        foreach ($val as $arrayIndex => $arrayItem) {
+          $arrayObject[$arrayIndex] =
+            $this->createObjectFromName($keyTypeName, $arrayItem);
+        }
+        $this->modelData[$key] = $arrayObject;
+      }
+      $this->processed[$key] = true;
+    }
+
+    return isset($this->modelData[$key]) ? $this->modelData[$key] : null;
+  }
+
+  /**
+   * Initialize this object's properties from an array.
+   *
+   * @param array $array Used to seed this object's properties.
+   * @return void
+   */
+  protected function mapTypes($array)
+  {
+    // Hard initilise simple types, lazy load more complex ones.
+    foreach ($array as $key => $val) {
+      if ( !property_exists($this, $this->keyType($key)) &&
+        property_exists($this, $key)) {
+          $this->$key = $val;
+          unset($array[$key]);
+      } elseif (property_exists($this, $camelKey = W3TCG_Google_Utils::camelCase($key))) {
+          // For backwards compatibility, this checks if property exists as camelCase, leaving
+          // it in array as snake_case
+          $this->$camelKey = $val;
+      }
+    }
+    $this->modelData = $array;
+  }
+
+  /**
+   * Blank initialiser to be used in subclasses to do  post-construction initialisation - this
+   * avoids the need for subclasses to have to implement the variadics handling in their
+   * constructors.
+   */
+  protected function gapiInit()
+  {
+    return;
+  }
+
+  /**
+   * Create a simplified object suitable for straightforward
+   * conversion to JSON. This is relatively expensive
+   * due to the usage of reflection, but shouldn't be called
+   * a whole lot, and is the most straightforward way to filter.
+   */
+  public function toSimpleObject()
+  {
+    $object = new stdClass();
+
+    // Process all other data.
+    foreach ($this->modelData as $key => $val) {
+      $result = $this->getSimpleValue($val);
+      if ($result !== null) {
+        $object->$key = $result;
+      }
+    }
+
+    // Process all public properties.
+    $reflect = new ReflectionObject($this);
+    $props = $reflect->getProperties(ReflectionProperty::IS_PUBLIC);
+    foreach ($props as $member) {
+      $name = $member->getName();
+      $result = $this->getSimpleValue($this->$name);
+      if ($result !== null) {
+        $name = $this->getMappedName($name);
+        $object->$name = $result;
+      }
+    }
+
+    return $object;
+  }
+
+  /**
+   * Handle different types of values, primarily
+   * other objects and map and array data types.
+   */
+  private function getSimpleValue($value)
+  {
+    if ($value instanceof W3TCG_Google_Model) {
+      return $value->toSimpleObject();
+    } else if (is_array($value)) {
+      $return = array();
+      foreach ($value as $key => $a_value) {
+        $a_value = $this->getSimpleValue($a_value);
+        if ($a_value !== null) {
+          $key = $this->getMappedName($key);
+          $return[$key] = $a_value;
+        }
+      }
+      return $return;
+    }
+    return $value;
+  }
+
+  /**
+   * If there is an internal name mapping, use that.
+   */
+  private function getMappedName($key)
+  {
+    if (isset($this->internal_gapi_mappings) &&
+        isset($this->internal_gapi_mappings[$key])) {
+      $key = $this->internal_gapi_mappings[$key];
+    }
+    return $key;
+  }
+
+  /**
+   * Returns true only if the array is associative.
+   * @param array $array
+   * @return bool True if the array is associative.
+   */
+  protected function isAssociativeArray($array)
+  {
+    if (!is_array($array)) {
+      return false;
+    }
+    $keys = array_keys($array);
+    foreach ($keys as $key) {
+      if (is_string($key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Given a variable name, discover its type.
+   *
+   * @param $name
+   * @param $item
+   * @return object The object from the item.
+   */
+  private function createObjectFromName($name, $item)
+  {
+    $type = $this->$name;
+    return new $type($item);
+  }
+
+  /**
+   * Verify if $obj is an array.
+   * @throws W3TCG_Google_Exception Thrown if $obj isn't an array.
+   * @param array $obj Items that should be validated.
+   * @param string $method Method expecting an array as an argument.
+   */
+  public function assertIsArray($obj, $method)
+  {
+    if ($obj && !is_array($obj)) {
+      throw new W3TCG_Google_Exception(
+          "Incorrect parameter type passed to $method(). Expected an array."
+      );
+    }
+  }
+
+  public function offsetExists($offset)
+  {
+    return isset($this->$offset) || isset($this->modelData[$offset]);
+  }
+
+  public function offsetGet($offset)
+  {
+    return isset($this->$offset) ?
+        $this->$offset :
+        $this->__get($offset);
+  }
+
+  public function offsetSet($offset, $value)
+  {
+    if (property_exists($this, $offset)) {
+      $this->$offset = $value;
+    } else {
+      $this->modelData[$offset] = $value;
+      $this->processed[$offset] = true;
+    }
+  }
+
+  public function offsetUnset($offset)
+  {
+    unset($this->modelData[$offset]);
+  }
+
+  protected function keyType($key)
+  {
+    return $key . "Type";
+  }
+
+  protected function dataType($key)
+  {
+    return $key . "DataType";
+  }
+
+  public function __isset($key)
+  {
+    return isset($this->modelData[$key]);
+  }
+
+  public function __unset($key)
+  {
+    unset($this->modelData[$key]);
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Service.php

@@ -0,0 +1,39 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class W3TCG_Google_Service
+{
+  public $version;
+  public $servicePath;
+  public $availableScopes;
+  public $resource;
+  private $client;
+
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    $this->client = $client;
+  }
+
+  /**
+   * Return the associated W3TCG_Google_Client class.
+   * @return W3TCG_Google_Client
+   */
+  public function getClient()
+  {
+    return $this->client;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Service/Exception.php

@@ -0,0 +1,51 @@
+<?php
+
+class W3TCG_Google_Service_Exception extends W3TCG_Google_Exception
+{
+  /**
+   * Optional list of errors returned in a JSON body of an HTTP error response.
+   */
+  protected $errors = array();
+
+  /**
+   * Override default constructor to add ability to set $errors.
+   *
+   * @param string $message
+   * @param int $code
+   * @param Exception|null $previous
+   * @param [{string, string}] errors List of errors returned in an HTTP
+   * response.  Defaults to [].
+   */
+  public function __construct(
+      $message,
+      $code = 0,
+      Exception $previous = null,
+      $errors = array()
+  ) {
+    if (version_compare(PHP_VERSION, '5.3.0') >= 0) {
+      parent::__construct($message, $code, $previous);
+    } else {
+      parent::__construct($message, $code);
+    }
+
+    $this->errors = $errors;
+  }
+
+  /**
+   * An example of the possible errors returned.
+   *
+   * {
+   *   "domain": "global",
+   *   "reason": "authError",
+   *   "message": "Invalid Credentials",
+   *   "locationType": "header",
+   *   "location": "Authorization",
+   * }
+   *
+   * @return [{string, string}] List of errors return in an HTTP response or [].
+   */
+  public function getErrors()
+  {
+    return $this->errors;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Service/Oauth2.php

@@ -0,0 +1,409 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+/**
+ * Service definition for Oauth2 (v2).
+ *
+ * <p>
+ * Lets you access OAuth2 protocol related APIs.
+ * </p>
+ *
+ * <p>
+ * For more information about this service, see the API
+ * <a href="https://developers.google.com/accounts/docs/OAuth2" target="_blank">Documentation</a>
+ * </p>
+ *
+ * @author Google, Inc.
+ */
+class W3TCG_Google_Service_Oauth2 extends W3TCG_Google_Service
+{
+  /** Know your basic profile info and list of people in your circles.. */
+  const PLUS_LOGIN = "https://www.googleapis.com/auth/plus.login";
+  /** Know who you are on Google. */
+  const PLUS_ME = "https://www.googleapis.com/auth/plus.me";
+  /** View your email address. */
+  const USERINFO_EMAIL = "https://www.googleapis.com/auth/userinfo.email";
+  /** View your basic profile info. */
+  const USERINFO_PROFILE = "https://www.googleapis.com/auth/userinfo.profile";
+
+  public $userinfo;
+  public $userinfo_v2_me;
+  private $base_methods;
+
+  /**
+   * Constructs the internal representation of the Oauth2 service.
+   *
+   * @param W3TCG_Google_Client $client
+   */
+  public function __construct(W3TCG_Google_Client $client)
+  {
+    parent::__construct($client);
+    $this->servicePath = '';
+    $this->version = 'v2';
+    $this->serviceName = 'oauth2';
+
+    $this->userinfo = new W3TCG_Google_Service_Oauth2_Userinfo_Resource(
+        $this,
+        $this->serviceName,
+        'userinfo',
+        array(
+          'methods' => array(
+            'get' => array(
+              'path' => 'oauth2/v2/userinfo',
+              'httpMethod' => 'GET',
+              'parameters' => array(),
+            ),
+          )
+        )
+    );
+    $this->userinfo_v2_me = new W3TCG_Google_Service_Oauth2_UserinfoV2Me_Resource(
+        $this,
+        $this->serviceName,
+        'me',
+        array(
+          'methods' => array(
+            'get' => array(
+              'path' => 'userinfo/v2/me',
+              'httpMethod' => 'GET',
+              'parameters' => array(),
+            ),
+          )
+        )
+    );
+    $this->base_methods = new W3TCG_Google_Service_Resource(
+        $this,
+        $this->serviceName,
+        '',
+        array(
+          'methods' => array(
+            'tokeninfo' => array(
+              'path' => 'oauth2/v2/tokeninfo',
+              'httpMethod' => 'POST',
+              'parameters' => array(
+                'access_token' => array(
+                  'location' => 'query',
+                  'type' => 'string',
+                ),
+                'id_token' => array(
+                  'location' => 'query',
+                  'type' => 'string',
+                ),
+              ),
+            ),
+          )
+        )
+    );
+  }
+  /**
+   * (tokeninfo)
+   *
+   * @param array $optParams Optional parameters.
+   *
+   * @opt_param string access_token
+   *
+   * @opt_param string id_token
+   *
+   * @return W3TCG_Google_Service_Oauth2_Tokeninfo
+   */
+  public function tokeninfo($optParams = array())
+  {
+    $params = array();
+    $params = array_merge($params, $optParams);
+    return $this->base_methods->call('tokeninfo', array($params), "W3TCG_Google_Service_Oauth2_Tokeninfo");
+  }
+}
+
+
+/**
+ * The "userinfo" collection of methods.
+ * Typical usage is:
+ *  <code>
+ *   $oauth2Service = new W3TCG_Google_Service_Oauth2(...);
+ *   $userinfo = $oauth2Service->userinfo;
+ *  </code>
+ */
+class W3TCG_Google_Service_Oauth2_Userinfo_Resource extends W3TCG_Google_Service_Resource
+{
+
+  /**
+   * (userinfo.get)
+   *
+   * @param array $optParams Optional parameters.
+   * @return W3TCG_Google_Service_Oauth2_Userinfoplus
+   */
+  public function get($optParams = array())
+  {
+    $params = array();
+    $params = array_merge($params, $optParams);
+    return $this->call('get', array($params), "W3TCG_Google_Service_Oauth2_Userinfoplus");
+  }
+}
+
+/**
+ * The "v2" collection of methods.
+ * Typical usage is:
+ *  <code>
+ *   $oauth2Service = new W3TCG_Google_Service_Oauth2(...);
+ *   $v2 = $oauth2Service->v2;
+ *  </code>
+ */
+class W3TCG_Google_Service_Oauth2_UserinfoV2_Resource extends W3TCG_Google_Service_Resource
+{
+
+}
+
+/**
+ * The "me" collection of methods.
+ * Typical usage is:
+ *  <code>
+ *   $oauth2Service = new W3TCG_Google_Service_Oauth2(...);
+ *   $me = $oauth2Service->me;
+ *  </code>
+ */
+class W3TCG_Google_Service_Oauth2_UserinfoV2Me_Resource extends W3TCG_Google_Service_Resource
+{
+
+  /**
+   * (me.get)
+   *
+   * @param array $optParams Optional parameters.
+   * @return W3TCG_Google_Service_Oauth2_Userinfoplus
+   */
+  public function get($optParams = array())
+  {
+    $params = array();
+    $params = array_merge($params, $optParams);
+    return $this->call('get', array($params), "W3TCG_Google_Service_Oauth2_Userinfoplus");
+  }
+}
+
+
+
+
+class W3TCG_Google_Service_Oauth2_Tokeninfo extends W3TCG_Google_Model
+{
+  protected $internal_gapi_mappings = array(
+        "accessType" => "access_type",
+        "expiresIn" => "expires_in",
+        "issuedTo" => "issued_to",
+        "userId" => "user_id",
+        "verifiedEmail" => "verified_email",
+  );
+  public $accessType;
+  public $audience;
+  public $email;
+  public $expiresIn;
+  public $issuedTo;
+  public $scope;
+  public $userId;
+  public $verifiedEmail;
+
+  public function setAccessType($accessType)
+  {
+    $this->accessType = $accessType;
+  }
+
+  public function getAccessType()
+  {
+    return $this->accessType;
+  }
+  public function setAudience($audience)
+  {
+    $this->audience = $audience;
+  }
+
+  public function getAudience()
+  {
+    return $this->audience;
+  }
+  public function setEmail($email)
+  {
+    $this->email = $email;
+  }
+
+  public function getEmail()
+  {
+    return $this->email;
+  }
+  public function setExpiresIn($expiresIn)
+  {
+    $this->expiresIn = $expiresIn;
+  }
+
+  public function getExpiresIn()
+  {
+    return $this->expiresIn;
+  }
+  public function setIssuedTo($issuedTo)
+  {
+    $this->issuedTo = $issuedTo;
+  }
+
+  public function getIssuedTo()
+  {
+    return $this->issuedTo;
+  }
+  public function setScope($scope)
+  {
+    $this->scope = $scope;
+  }
+
+  public function getScope()
+  {
+    return $this->scope;
+  }
+  public function setUserId($userId)
+  {
+    $this->userId = $userId;
+  }
+
+  public function getUserId()
+  {
+    return $this->userId;
+  }
+  public function setVerifiedEmail($verifiedEmail)
+  {
+    $this->verifiedEmail = $verifiedEmail;
+  }
+
+  public function getVerifiedEmail()
+  {
+    return $this->verifiedEmail;
+  }
+
+}
+
+class W3TCG_Google_Service_Oauth2_Userinfoplus extends W3TCG_Google_Model
+{
+  protected $internal_gapi_mappings = array(
+        "familyName" => "family_name",
+        "givenName" => "given_name",
+        "verifiedEmail" => "verified_email",
+  );
+  public $email;
+  public $familyName;
+  public $gender;
+  public $givenName;
+  public $hd;
+  public $id;
+  public $link;
+  public $locale;
+  public $name;
+  public $picture;
+  public $verifiedEmail;
+
+  public function setEmail($email)
+  {
+    $this->email = $email;
+  }
+
+  public function getEmail()
+  {
+    return $this->email;
+  }
+  public function setFamilyName($familyName)
+  {
+    $this->familyName = $familyName;
+  }
+
+  public function getFamilyName()
+  {
+    return $this->familyName;
+  }
+  public function setGender($gender)
+  {
+    $this->gender = $gender;
+  }
+
+  public function getGender()
+  {
+    return $this->gender;
+  }
+  public function setGivenName($givenName)
+  {
+    $this->givenName = $givenName;
+  }
+
+  public function getGivenName()
+  {
+    return $this->givenName;
+  }
+  public function setHd($hd)
+  {
+    $this->hd = $hd;
+  }
+
+  public function getHd()
+  {
+    return $this->hd;
+  }
+  public function setId($id)
+  {
+    $this->id = $id;
+  }
+
+  public function getId()
+  {
+    return $this->id;
+  }
+  public function setLink($link)
+  {
+    $this->link = $link;
+  }
+
+  public function getLink()
+  {
+    return $this->link;
+  }
+  public function setLocale($locale)
+  {
+    $this->locale = $locale;
+  }
+
+  public function getLocale()
+  {
+    return $this->locale;
+  }
+  public function setName($name)
+  {
+    $this->name = $name;
+  }
+
+  public function getName()
+  {
+    return $this->name;
+  }
+  public function setPicture($picture)
+  {
+    $this->picture = $picture;
+  }
+
+  public function getPicture()
+  {
+    return $this->picture;
+  }
+  public function setVerifiedEmail($verifiedEmail)
+  {
+    $this->verifiedEmail = $verifiedEmail;
+  }
+
+  public function getVerifiedEmail()
+  {
+    return $this->verifiedEmail;
+  }
+
+}

wp-content/plugins/w3-total-cache/lib/Google/Service/Resource.php

@@ -0,0 +1,203 @@
+<?php
+/**
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implements the actual methods/resources of the discovered Google API using magic function
+ * calling overloading (__call()), which on call will see if the method name (plus.activities.list)
+ * is available in this service, and if so construct an apiHttpRequest representing it.
+ *
+ * @author Chris Chabot <chabotc@google.com>
+ * @author Chirag Shah <chirags@google.com>
+ *
+ */
+class W3TCG_Google_Service_Resource
+{
+  // Valid query parameters that work, but don't appear in discovery.
+  private $stackParameters = array(
+      'alt' => array('type' => 'string', 'location' => 'query'),
+      'fields' => array('type' => 'string', 'location' => 'query'),
+      'trace' => array('type' => 'string', 'location' => 'query'),
+      'userIp' => array('type' => 'string', 'location' => 'query'),
+      'userip' => array('type' => 'string', 'location' => 'query'),
+      'quotaUser' => array('type' => 'string', 'location' => 'query'),
+      'data' => array('type' => 'string', 'location' => 'body'),
+      'mimeType' => array('type' => 'string', 'location' => 'header'),
+      'uploadType' => array('type' => 'string', 'location' => 'query'),
+      'mediaUpload' => array('type' => 'complex', 'location' => 'query'),
+  );
+
+  /** @var W3TCG_Google_Service $service */
+  private $service;
+
+  /** @var W3TCG_Google_Client $client */
+  private $client;
+
+  /** @var string $serviceName */
+  private $serviceName;
+
+  /** @var string $resourceName */
+  private $resourceName;
+
+  /** @var array $methods */
+  private $methods;
+
+  public function __construct($service, $serviceName, $resourceName, $resource)
+  {
+    $this->service = $service;
+    $this->client = $service->getClient();
+    $this->serviceName = $serviceName;
+    $this->resourceName = $resourceName;
+    $this->methods = isset($resource['methods']) ?
+        $resource['methods'] :
+        array($resourceName => $resource);
+  }
+
+  /**
+   * TODO(ianbarber): This function needs simplifying.
+   * @param $name
+   * @param $arguments
+   * @param $expected_class - optional, the expected class name
+   * @return W3TCG_Google_Http_Request|expected_class
+   * @throws W3TCG_Google_Exception
+   */
+  public function call($name, $arguments, $expected_class = null)
+  {
+    if (! isset($this->methods[$name])) {
+      throw new W3TCG_Google_Exception(
+          "Unknown function: " .
+          "{$this->serviceName}->{$this->resourceName}->{$name}()"
+      );
+    }
+    $method = $this->methods[$name];
+    $parameters = $arguments[0];
+
+    // postBody is a special case since it's not defined in the discovery
+    // document as parameter, but we abuse the param entry for storing it.
+    $postBody = null;
+    if (isset($parameters['postBody'])) {
+      if ($parameters['postBody'] instanceof W3TCG_Google_Model) {
+        // In the cases the post body is an existing object, we want
+        // to use the smart method to create a simple object for
+        // for JSONification.
+        $parameters['postBody'] = $parameters['postBody']->toSimpleObject();
+      } else if (is_object($parameters['postBody'])) {
+        // If the post body is another kind of object, we will try and
+        // wrangle it into a sensible format.
+        $parameters['postBody'] =
+            $this->convertToArrayAndStripNulls($parameters['postBody']);
+      }
+      $postBody = json_encode($parameters['postBody']);
+      unset($parameters['postBody']);
+    }
+
+    // TODO(ianbarber): optParams here probably should have been
+    // handled already - this may well be redundant code.
+    if (isset($parameters['optParams'])) {
+      $optParams = $parameters['optParams'];
+      unset($parameters['optParams']);
+      $parameters = array_merge($parameters, $optParams);
+    }
+
+    if (!isset($method['parameters'])) {
+      $method['parameters'] = array();
+    }
+
+    $method['parameters'] = array_merge(
+        $method['parameters'],
+        $this->stackParameters
+    );
+    foreach ($parameters as $key => $val) {
+      if ($key != 'postBody' && ! isset($method['parameters'][$key])) {
+        throw new W3TCG_Google_Exception("($name) unknown parameter: '$key'");
+      }
+    }
+
+    foreach ($method['parameters'] as $paramName => $paramSpec) {
+      if (isset($paramSpec['required']) &&
+          $paramSpec['required'] &&
+          ! isset($parameters[$paramName])
+      ) {
+        throw new W3TCG_Google_Exception("($name) missing required param: '$paramName'");
+      }
+      if (isset($parameters[$paramName])) {
+        $value = $parameters[$paramName];
+        $parameters[$paramName] = $paramSpec;
+        $parameters[$paramName]['value'] = $value;
+        unset($parameters[$paramName]['required']);
+      } else {
+        // Ensure we don't pass nulls.
+        unset($parameters[$paramName]);
+      }
+    }
+
+    $servicePath = $this->service->servicePath;
+
+    $url = W3TCG_Google_Http_REST::createRequestUri(
+        $servicePath,
+        $method['path'],
+        $parameters
+    );
+    $httpRequest = new W3TCG_Google_Http_Request(
+        $url,
+        $method['httpMethod'],
+        null,
+        $postBody
+    );
+    $httpRequest->setBaseComponent($this->client->getBasePath());
+
+    if ($postBody) {
+      $contentTypeHeader = array();
+      $contentTypeHeader['content-type'] = 'application/json; charset=UTF-8';
+      $httpRequest->setRequestHeaders($contentTypeHeader);
+      $httpRequest->setPostBody($postBody);
+    }
+
+    $httpRequest = $this->client->getAuth()->sign($httpRequest);
+    $httpRequest->setExpectedClass($expected_class);
+
+    if (isset($parameters['data']) &&
+        ($parameters['uploadType']['value'] == 'media' || $parameters['uploadType']['value'] == 'multipart')) {
+      // If we are doing a simple media upload, trigger that as a convenience.
+      $mfu = new W3TCG_Google_Http_MediaFileUpload(
+          $this->client,
+          $httpRequest,
+          isset($parameters['mimeType']) ? $parameters['mimeType']['value'] : 'application/octet-stream',
+          $parameters['data']['value']
+      );
+    }
+
+    if ($this->client->shouldDefer()) {
+      // If we are in batch or upload mode, return the raw request.
+      return $httpRequest;
+    }
+
+    return $this->client->execute($httpRequest);
+  }
+
+  protected function convertToArrayAndStripNulls($o)
+  {
+    $o = (array) $o;
+    foreach ($o as $k => $v) {
+      if ($v === null) {
+        unset($o[$k]);
+      } elseif (is_object($v) || is_array($v)) {
+        $o[$k] = $this->convertToArrayAndStripNulls($o[$k]);
+      }
+    }
+    return $o;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Signer/Abstract.php

@@ -0,0 +1,29 @@
+<?php
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Signs data.
+ *
+ * @author Brian Eaton <beaton@google.com>
+ */
+abstract class W3TCG_Google_Signer_Abstract
+{
+  /**
+   * Signs data, returns the signature as binary data.
+   */
+  abstract public function sign($data);
+}

wp-content/plugins/w3-total-cache/lib/Google/Signer/P12.php

@@ -0,0 +1,88 @@
+<?php
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Signs data.
+ *
+ * Only used for testing.
+ *
+ * @author Brian Eaton <beaton@google.com>
+ */
+class W3TCG_Google_Signer_P12 extends W3TCG_Google_Signer_Abstract
+{
+  // OpenSSL private key resource
+  private $privateKey;
+
+  // Creates a new signer from a .p12 file.
+  public function __construct($p12, $password)
+  {
+    if (!function_exists('openssl_x509_read')) {
+      throw new W3TCG_Google_Exception(
+          'The Google PHP API library needs the openssl PHP extension'
+      );
+    }
+
+    // If the private key is provided directly, then this isn't in the p12
+    // format. Different versions of openssl support different p12 formats
+    // and the key from google wasn't being accepted by the version available
+    // at the time.
+    if (!$password && strpos($p12, "-----BEGIN RSA PRIVATE KEY-----") !== false) {
+      $this->privateKey = openssl_pkey_get_private($p12);
+    } else {
+      // This throws on error
+      $certs = array();
+      if (!openssl_pkcs12_read($p12, $certs, $password)) {
+        throw new W3TCG_Google_Auth_Exception(
+            "Unable to parse the p12 file.  " .
+            "Is this a .p12 file?  Is the password correct?  OpenSSL error: " .
+            openssl_error_string()
+        );
+      }
+      // TODO(beaton): is this part of the contract for the openssl_pkcs12_read
+      // method?  What happens if there are multiple private keys?  Do we care?
+      if (!array_key_exists("pkey", $certs) || !$certs["pkey"]) {
+        throw new W3TCG_Google_Auth_Exception("No private key found in p12 file.");
+      }
+      $this->privateKey = openssl_pkey_get_private($certs['pkey']);
+    }
+
+    if (!$this->privateKey) {
+      throw new W3TCG_Google_Auth_Exception("Unable to load private key");
+    }
+  }
+
+  public function __destruct()
+  {
+    if ($this->privateKey) {
+      openssl_pkey_free($this->privateKey);
+    }
+  }
+
+  public function sign($data)
+  {
+    if (version_compare(PHP_VERSION, '5.3.0') < 0) {
+      throw new W3TCG_Google_Auth_Exception(
+          "PHP 5.3.0 or higher is required to use service accounts."
+      );
+    }
+    $hash = defined("OPENSSL_ALGO_SHA256") ? OPENSSL_ALGO_SHA256 : "sha256";
+    if (!openssl_sign($data, $signature, $this->privateKey, $hash)) {
+      throw new W3TCG_Google_Auth_Exception("Unable to sign data");
+    }
+    return $signature;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Utils.php

@@ -0,0 +1,151 @@
+<?php
+/**
+ * File: Utils.php
+ *
+ * @package W3TC
+ */
+
+/**
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Collection of static utility methods used for convenience across
+ * the client library.
+ *
+ * @author Chirag Shah <chirags@google.com>
+ */
+class W3TCG_Google_Utils {
+	/**
+	 * URL safe base 64 encoder function
+	 *
+	 * @param string $data URL to be base 64 encoded.
+	 *
+	 * @return string
+	 */
+	public static function urlSafeB64Encode( $data ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
+		$b64 = base64_encode( $data ); // phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.obfuscation_base64_encode
+		$b64 = str_replace(
+			array( '+', '/', '\r', '\n', '=' ),
+			array( '-', '_' ),
+			$b64
+		);
+		return $b64;
+	}
+
+	/**
+	 * URL safe base 64 de-coder function
+	 *
+	 * @param string $b64 Base 64 encoded string.
+	 *
+	 * @return string
+	 */
+	public static function urlSafeB64Decode( $b64 ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
+		$b64 = str_replace(
+			array( '-', '_' ),
+			array( '+', '/' ),
+			$b64
+		);
+		return base64_decode( $b64 ); // phpcs:ignore WordPress.PHP.DiscouragedPHPFunctions.obfuscation_base64_decode
+	}
+
+	/**
+	 * Misc function used to count the number of bytes in a post body, in the
+	 * world of multi-byte chars and the unpredictability of
+	 * strlen/mb_strlen/sizeof, this is the only way to do that in a sane
+	 * manner at the moment.
+	 *
+	 * This algorithm was originally developed for the
+	 * Solar Framework by Paul M. Jones
+	 *
+	 * @link   http://solarphp.com/
+	 * @link   http://svn.solarphp.com/core/trunk/Solar/Json.php
+	 * @link   http://framework.zend.com/svn/framework/standard/trunk/library/Zend/Json/Decoder.php
+	 * @param  string $str String to get length of.
+	 * @return int The number of bytes in a string.
+	 */
+	public static function getStrLen( $str ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
+		$strlen_var = strlen( $str );
+		$ret        = 0;
+		for ( $count = 0; $count < $strlen_var; ++ $count ) {
+			$ordinal_value = ord( $str[ $ret ] );
+			switch ( true ) {
+				case ( ( $ordinal_value >= 0x20 ) && ( $ordinal_value <= 0x7F ) ):
+					// characters U-00000000 - U-0000007F (same as ASCII).
+					$ret ++;
+					break;
+				case ( ( $ordinal_value & 0xE0 ) === 0xC0 ):
+					// characters U-00000080 - U-000007FF, mask 110XXXXX.
+					// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8.
+					$ret += 2;
+					break;
+				case ( ( $ordinal_value & 0xF0 ) === 0xE0 ):
+					// characters U-00000800 - U-0000FFFF, mask 1110XXXX.
+					// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8.
+					$ret += 3;
+					break;
+				case ( ( $ordinal_value & 0xF8 ) === 0xF0 ):
+					// characters U-00010000 - U-001FFFFF, mask 11110XXX.
+					// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8.
+					$ret += 4;
+					break;
+				case ( ( $ordinal_value & 0xFC ) === 0xF8 ):
+					// characters U-00200000 - U-03FFFFFF, mask 111110XX.
+					// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8.
+					$ret += 5;
+					break;
+				case ( ( $ordinal_value & 0xFE ) === 0xFC ):
+					// characters U-04000000 - U-7FFFFFFF, mask 1111110X.
+					// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8.
+					$ret += 6;
+					break;
+				default:
+					$ret ++;
+			}
+		}
+
+		return $ret;
+	}
+
+	/**
+	 * Normalize all keys in an array to lower-case.
+	 *
+	 * @param array $arr Array to normalize all keys to lowercase.
+	 * @return array Normalized array.
+	 */
+	public static function normalize( $arr ) {
+		if ( ! is_array( $arr ) ) {
+			return array();
+		}
+		$normalized = array();
+		foreach ( $arr as $key => $val ) {
+			$normalized[ strtolower( $key ) ] = $val;
+		}
+		return $normalized;
+	}
+
+	/**
+	 * Convert a string to camelCase
+	 *
+	 * @param  string $value String to convert to camelCase.
+	 * @return string
+	 */
+	public static function camelCase( $value ) { // phpcs:ignore WordPress.NamingConventions.ValidFunctionName.MethodNameInvalid
+		$value    = ucwords( str_replace( array( '-', '_' ), ' ', $value ) );
+		$value    = str_replace( ' ', '', $value );
+		$value[0] = strtolower( $value[0] );
+		return $value;
+	}
+}

wp-content/plugins/w3-total-cache/lib/Google/Utils/URITemplate.php

@@ -0,0 +1,333 @@
+<?php
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Implementation of levels 1-3 of the URI Template spec. 
+ * @see http://tools.ietf.org/html/rfc6570
+ */
+class W3TCG_Google_Utils_URITemplate
+{
+  const TYPE_MAP = "1";
+  const TYPE_LIST = "2";
+  const TYPE_SCALAR = "4";
+
+  /**
+   * @var $operators array 
+   * These are valid at the start of a template block to
+   * modify the way in which the variables inside are
+   * processed.
+   */
+  private $operators = array(
+      "+" => "reserved",
+      "/" => "segments",
+      "." => "dotprefix",
+      "#" => "fragment",
+      ";" => "semicolon",
+      "?" => "form",
+      "&" => "continuation"
+  );
+
+  /**
+   * @var reserved array
+   * These are the characters which should not be URL encoded in reserved
+   * strings.
+   */
+  private $reserved = array(
+      "=", ",", "!", "@", "|", ":", "/", "?", "#",
+      "[", "]",'$', "&", "'", "(", ")", "*", "+", ";"
+  );
+  private $reservedEncoded = array(
+    "%3D", "%2C", "%21", "%40", "%7C", "%3A", "%2F", "%3F",
+    "%23", "%5B", "%5D", "%24", "%26", "%27", "%28", "%29",
+    "%2A", "%2B", "%3B"
+  );
+
+  public function parse($string, array $parameters)
+  {
+    return $this->resolveNextSection($string, $parameters);
+  }
+
+  /**
+   * This function finds the first matching {...} block and
+   * executes the replacement. It then calls itself to find
+   * subsequent blocks, if any. 
+   */
+  private function resolveNextSection($string, $parameters)
+  {
+    $start = strpos($string, "{");
+    if ($start === false) {
+      return $string;
+    }
+    $end = strpos($string, "}");
+    if ($end === false) {
+      return $string;
+    }
+    $string = $this->replace($string, $start, $end, $parameters);
+    return $this->resolveNextSection($string, $parameters);
+  }
+
+  private function replace($string, $start, $end, $parameters)
+  {
+    // We know a data block will have {} round it, so we can strip that.
+    $data = substr($string, $start + 1, $end - $start - 1);
+
+    // If the first character is one of the reserved operators, it effects
+    // the processing of the stream.
+    if (isset($this->operators[$data[0]])) {
+      $op = $this->operators[$data[0]];
+      $data = substr($data, 1);
+      $prefix = "";
+      $prefix_on_missing = false;
+
+      switch ($op) {
+        case "reserved":
+          // Reserved means certain characters should not be URL encoded
+          $data = $this->replaceVars($data, $parameters, ",", null, true);
+          break;
+        case "fragment":
+          // Comma separated with fragment prefix. Bare values only.
+          $prefix = "#";
+          $prefix_on_missing = true;
+          $data = $this->replaceVars($data, $parameters, ",", null, true);
+          break;
+        case "segments":
+          // Slash separated data. Bare values only.
+          $prefix = "/";
+          $data =$this->replaceVars($data, $parameters, "/");
+          break;
+        case "dotprefix":
+          // Dot separated data. Bare values only.
+          $prefix = ".";
+          $prefix_on_missing = true;
+          $data = $this->replaceVars($data, $parameters, ".");
+          break;
+        case "semicolon":
+          // Semicolon prefixed and separated. Uses the key name
+          $prefix = ";";
+          $data = $this->replaceVars($data, $parameters, ";", "=", false, true, false);
+          break;
+        case "form":
+          // Standard URL format. Uses the key name
+          $prefix = "?";
+          $data = $this->replaceVars($data, $parameters, "&", "=");
+          break;
+        case "continuation":
+          // Standard URL, but with leading ampersand. Uses key name.
+          $prefix = "&";
+          $data = $this->replaceVars($data, $parameters, "&", "=");
+          break;
+      }
+
+      // Add the initial prefix character if data is valid.
+      if ($data || ($data !== false && $prefix_on_missing)) {
+        $data = $prefix . $data;
+      }
+
+    } else {
+      // If no operator we replace with the defaults.
+      $data = $this->replaceVars($data, $parameters);
+    }
+    // This is chops out the {...} and replaces with the new section.
+    return substr($string, 0, $start) . $data . substr($string, $end + 1);
+  }
+
+  private function replaceVars(
+      $section,
+      $parameters,
+      $sep = ",",
+      $combine = null,
+      $reserved = false,
+      $tag_empty = false,
+      $combine_on_empty = true
+  ) {
+    if (strpos($section, ",") === false) {
+      // If we only have a single value, we can immediately process.
+      return $this->combine(
+          $section,
+          $parameters,
+          $sep,
+          $combine,
+          $reserved,
+          $tag_empty,
+          $combine_on_empty
+      );
+    } else {
+      // If we have multiple values, we need to split and loop over them.
+      // Each is treated individually, then glued together with the
+      // separator character.
+      $vars = explode(",", $section);
+      return $this->combineList(
+          $vars,
+          $sep,
+          $parameters,
+          $combine,
+          $reserved,
+          false, // Never emit empty strings in multi-param replacements
+          $combine_on_empty
+      );
+    }
+  }
+ 
+  public function combine(
+      $key,
+      $parameters,
+      $sep,
+      $combine,
+      $reserved,
+      $tag_empty,
+      $combine_on_empty
+  ) {
+    $length = false;
+    $explode = false;
+    $skip_final_combine = false;
+    $value = false;
+
+    // Check for length restriction.
+    if (strpos($key, ":") !== false) {
+      list($key, $length) = explode(":", $key);
+    }
+    
+    // Check for explode parameter.
+    if ($key[strlen($key) - 1] == "*") {
+      $explode = true;
+      $key = substr($key, 0, -1);
+      $skip_final_combine = true;
+    }
+    
+    // Define the list separator.
+    $list_sep = $explode ? $sep : ",";
+    
+    if (isset($parameters[$key])) {
+      $data_type = $this->getDataType($parameters[$key]);
+      switch($data_type) {
+        case self::TYPE_SCALAR:
+          $value = $this->getValue($parameters[$key], $length);
+          break;
+        case self::TYPE_LIST:
+          $values = array();
+          foreach ($parameters[$key] as $pkey => $pvalue) {
+            $pvalue = $this->getValue($pvalue, $length);
+            if ($combine && $explode) {
+              $values[$pkey] = $key . $combine . $pvalue;
+            } else {
+              $values[$pkey] = $pvalue;
+            }
+          }
+          $value = implode($list_sep, $values);
+          if ($value == '') {
+            return '';
+          }
+          break;
+        case self::TYPE_MAP:
+          $values = array();
+          foreach ($parameters[$key] as $pkey => $pvalue) {
+            $pvalue = $this->getValue($pvalue, $length);
+            if ($explode) {
+              $pkey = $this->getValue($pkey, $length);
+              $values[] = $pkey . "=" . $pvalue; // Explode triggers = combine.
+            } else {
+              $values[] = $pkey;
+              $values[] = $pvalue;
+            }
+          }
+          $value = implode($list_sep, $values);
+          if ($value == '') {
+            return false;
+          }
+          break;
+      }
+    } else if ($tag_empty) {
+      // If we are just indicating empty values with their key name, return that.
+      return $key;
+    } else {
+      // Otherwise we can skip this variable due to not being defined.
+      return false;
+    }
+
+    if ($reserved) {
+      $value = str_replace($this->reservedEncoded, $this->reserved, $value);
+    }
+
+    // If we do not need to include the key name, we just return the raw
+    // value.
+    if (!$combine || $skip_final_combine) {
+      return $value;
+    }
+        
+    // Else we combine the key name: foo=bar, if value is not the empty string.
+    return $key . ($value != '' || $combine_on_empty ? $combine . $value : '');
+  }
+  
+  /**
+   * Return the type of a passed in value
+   */
+  private function getDataType($data)
+  {
+    if (is_array($data)) {
+      reset($data);
+      if (key($data) !== 0) {
+        return self::TYPE_MAP;
+      }
+      return self::TYPE_LIST;
+    }
+    return self::TYPE_SCALAR;
+  }
+  
+  /**
+   * Utility function that merges multiple combine calls
+   * for multi-key templates.
+   */
+  private function combineList(
+      $vars,
+      $sep,
+      $parameters,
+      $combine,
+      $reserved,
+      $tag_empty,
+      $combine_on_empty
+  ) {
+    $ret = array();
+    foreach ($vars as $var) {
+      $response = $this->combine(
+          $var,
+          $parameters,
+          $sep,
+          $combine,
+          $reserved,
+          $tag_empty,
+          $combine_on_empty
+      );
+      if ($response === false) {
+        continue;
+      }
+      $ret[] = $response;
+    }
+    return implode($sep, $ret);
+  }
+  
+  /**
+   * Utility function to encode and trim values
+   */
+  private function getValue($value, $length)
+  {
+    if ($length) {
+      $value = substr($value, 0, $length);
+    }
+    $value = rawurlencode($value);
+    return $value;
+  }
+}

wp-content/plugins/w3-total-cache/lib/Google/Verifier/Abstract.php

@@ -0,0 +1,30 @@
+<?php
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Verifies signatures.
+ *
+ * @author Brian Eaton <beaton@google.com>
+ */
+abstract class W3TCG_Google_Verifier_Abstract
+{
+  /**
+   * Checks a signature, returns true if the signature is correct,
+   * false otherwise.
+   */
+  abstract public function verify($data, $signature);
+}

wp-content/plugins/w3-total-cache/lib/Google/Verifier/Pem.php

@@ -0,0 +1,71 @@
+<?php
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+/**
+ * Verifies signatures using PEM encoded certificates.
+ *
+ * @author Brian Eaton <beaton@google.com>
+ */
+class W3TCG_Google_Verifier_Pem extends W3TCG_Google_Verifier_Abstract
+{
+  private $publicKey;
+
+  /**
+   * Constructs a verifier from the supplied PEM-encoded certificate.
+   *
+   * $pem: a PEM encoded certificate (not a file).
+   * @param $pem
+   * @throws W3TCG_Google_Auth_Exception
+   * @throws W3TCG_Google_Exception
+   */
+  public function __construct($pem)
+  {
+    if (!function_exists('openssl_x509_read')) {
+      throw new W3TCG_Google_Exception('Google API PHP client needs the openssl PHP extension');
+    }
+    $this->publicKey = openssl_x509_read($pem);
+    if (!$this->publicKey) {
+      throw new W3TCG_Google_Auth_Exception("Unable to parse PEM: $pem");
+    }
+  }
+
+  public function __destruct()
+  {
+    if ($this->publicKey) {
+      openssl_x509_free($this->publicKey);
+    }
+  }
+
+  /**
+   * Verifies the signature on data.
+   *
+   * Returns true if the signature is valid, false otherwise.
+   * @param $data
+   * @param $signature
+   * @throws W3TCG_Google_Auth_Exception
+   * @return bool
+   */
+  public function verify($data, $signature)
+  {
+    $hash = defined("OPENSSL_ALGO_SHA256") ? OPENSSL_ALGO_SHA256 : "sha256";
+    $status = openssl_verify($data, $signature, $this->publicKey, $hash);
+    if ($status === -1) {
+      throw new W3TCG_Google_Auth_Exception('Signature verification error: ' . openssl_error_string());
+    }
+    return $status === 1;
+  }
+}