Add read-only access to POST data for webRequest's onBeforeRequest

chrome/browser/extensions/api/web_request/web_request_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rule.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h"
+#include "chrome/browser/extensions/api/web_request/post_data_parser.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/web_request_time_tracker.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_id_map.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/base/auth.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "ui/base/l10n/l10n_util.h"
 
+using chrome::VersionInfo;
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using extensions::Extension;
 
 using extensions::web_navigation_api_helpers::GetFrameId;
 
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
 
 namespace {
 
 // List of all the webRequest events.
-static const char* const kWebRequestEvents[] = {
+const char* const kWebRequestEvents[] = {
   keys::kOnBeforeRedirect,
   keys::kOnBeforeRequest,
   keys::kOnBeforeSendHeaders,
   keys::kOnCompleted,
   keys::kOnErrorOccurred,
   keys::kOnSendHeaders,
   keys::kOnAuthRequired,
   keys::kOnResponseStarted,
   keys::kOnHeadersReceived,
 };
 
 #define ARRAYEND(array) (array + arraysize(array))
 
+bool g_channel_cached = false;
+VersionInfo::Channel g_channel = VersionInfo::CHANNEL_UNKNOWN;
+
+// Access to request body (crbug.com/91191/) is currently only enabled in dev
+// and canary channels. This function caches the release channel info from
+// chrome::VersionInfo. Don't use this outside IO thread.
+bool IsWebRequestBodyDataAccessEnabled() {
+  if (!g_channel_cached) {
+    g_channel = VersionInfo::GetChannel();
+    g_channel_cached = true;
+  }
+  return g_channel <= VersionInfo::CHANNEL_DEV;
+}
+
 bool IsWebRequestEvent(const std::string& event_name) {
   return std::find(kWebRequestEvents, ARRAYEND(kWebRequestEvents),
                    event_name) != ARRAYEND(kWebRequestEvents);
 }
 
 // Returns whether |request| has been triggered by an extension in
 // |extension_info_map|.
 bool IsRequestFromExtension(const net::URLRequest* request,
                             const ExtensionInfoMap* extension_info_map) {
   // |extension_info_map| is NULL for system-level requests.
@@ skipping 60 matching lines @@
                  base::Uint64ToString(request->identifier()));
   out->SetString(keys::kUrlKey, request->url().spec());
   out->SetString(keys::kMethodKey, request->method());
   out->SetInteger(keys::kFrameIdKey, frame_id_for_extension);
   out->SetInteger(keys::kParentFrameIdKey, parent_frame_id_for_extension);
   out->SetInteger(keys::kTabIdKey, tab_id);
   out->SetString(keys::kTypeKey, helpers::ResourceTypeToString(resource_type));
   out->SetDouble(keys::kTimeStampKey, base::Time::Now().ToDoubleT() * 1000);
 }
 
+// Extracts the body from |request| and writes the data into |out|.
+void ExtractRequestInfoBody(const net::URLRequest* request,
+                            DictionaryValue* out) {
+  if (request->method() != "POST" && request->method() != "PUT")
+    return;  // Need to exit without "out->Set(keys::kBodyKey, ...);" .
+
+  DictionaryValue* body = new DictionaryValue();
+  out->Set(keys::kBodyKey, body);
+
+  // Get the data producers, ordered by being interesting.
+  extensions::ChunkedErrorProducer chunked_error_producer(request);
+  extensions::RawDataProducer raw_data_producer;
+  extensions::ParsedDataProducer parsed_data_producer(request);
+  extensions::RequestDataRepresentationProducer* const kProducers[] = {

[Matt Perry, 2012/08/06 21:06:45]

just "producers". While "const", this variable doesn't really represent a
"constant" value.

[vabr (Chromium), 2012/08/10 17:12:55]

Done.

+    &chunked_error_producer,  // First  -- any errors?
+    &parsed_data_producer,    // Second -- any parseable forms?
+    &raw_data_producer        // Third  -- any data at all?
+  };
+  // Keys for the results of the corresponding producers.
+  static const char* const kKeys[] = {
+    keys::kBodyErrorKey,
+    keys::kBodyParsedFormKey,
+    keys::kBodyRawKey
+  };
+
+  const std::vector<net::UploadData::Element>* elements =
+      request->get_upload()->elements();
+  bool some_succeeded = false;
+  for (size_t n = 0; !some_succeeded && n < arraysize(kProducers); ++n) {

[wtc, 2012/08/09 23:39:40]

Nit: this kind of for loop index variable is traditionally
named 'i'.  'n' usually is used for the number of elements.
(This convention probably comes from math and Fortran).

[vabr (Chromium), 2012/08/10 17:12:55]

Done.
I agree, Index versus Number (of).

+    std::vector<net::UploadData::Element>::const_iterator element;
+    for (element = elements->begin(); element != elements->end(); ++element) {
+      kProducers[n]->FeedNext(*element);
+    }
+    if (kProducers[n]->Succeeded()) {
+      body->Set(kKeys[n], kProducers[n]->Result().release());
+      some_succeeded = true;
+    }
+  }
+  if (!some_succeeded) {
+    body->SetString(keys::kBodyErrorKey, "Unknown error.");
+  }
+}
+
 // Converts a HttpHeaders dictionary to a |name|, |value| pair. Returns
 // true if successful.
 bool FromHeaderDictionary(const DictionaryValue* header_value,
                           std::string* name,
                           std::string* value) {
   if (!header_value->GetString(keys::kHeaderNameKey, name))
     return false;
 
   // We require either a "value" or a "binaryValue" entry.
   if (!(header_value->HasKey(keys::kHeaderValueKey) ^
@@ skipping 74 matching lines @@
       SendExtensionWebRequestStatusToHost(host);
   }
 }
 
 void ClearCacheOnNavigationOnUI() {
   WebCacheManager::GetInstance()->ClearCacheOnNavigation();
 }
 
 }  // namespace
 
+// Don't use this outside IO thread.
+void WebRequestSetChannelForTesting(VersionInfo::Channel channel) {
+  g_channel = channel;
+  g_channel_cached = true;
+}
+
+// Don't use this outside IO thread.
+void WebRequestResetChannelForTesting() {
+  g_channel_cached = false;
+}
+
 // Represents a single unique listener to an event, along with whatever filter
 // parameters and extra_info_spec were specified at the time the listener was
 // added.
 struct ExtensionWebRequestEventRouter::EventListener {
   std::string extension_id;
   std::string extension_name;
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
   base::WeakPtr<IPC::Sender> ipc_sender;
@@ skipping 138 matching lines @@
       return false;
 
     if (str == "requestHeaders")
       *extra_info_spec |= REQUEST_HEADERS;
     else if (str == "responseHeaders")
       *extra_info_spec |= RESPONSE_HEADERS;
     else if (str == "blocking")
       *extra_info_spec |= BLOCKING;
     else if (str == "asyncBlocking")
       *extra_info_spec |= ASYNC_BLOCKING;
+    else if (str == "body")
+      *extra_info_spec |= IsWebRequestBodyDataAccessEnabled() ? BODY : 0;
     else
       return false;
 
     // BLOCKING and ASYNC_BLOCKING are mutually exclusive.
     if ((*extra_info_spec & BLOCKING) && (*extra_info_spec & ASYNC_BLOCKING))
       return false;
   }
   return true;
 }
 
@@ skipping 69 matching lines @@
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map, keys::kOnBeforeRequest,
                            request, &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeRequest)) {
     ListValue args;
     DictionaryValue* dict = new DictionaryValue();
     ExtractRequestInfo(request, dict);
+    if (extra_info_spec & ExtraInfoSpec::BODY)
+      ExtractRequestInfoBody(request, dict);
     args.Append(dict);
 
     initialize_blocked_requests |=
         DispatchEvent(profile, request, listeners, args);
   }
 
   if (!initialize_blocked_requests)
     return net::OK;  // Nobody saw a reason for modifying the request.
 
   blocked_requests_[request->identifier()].event = kOnBeforeRequest;
@@ skipping 1309 matching lines @@
       } else if ((*it)->name().find("AdBlock") != std::string::npos) {
         adblock = true;
       } else {
         other = true;
       }
     }
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(adblock, adblock_plus, other));
 }