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/upload_data_presenter.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"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
 #include "chrome/common/extensions/event_filtering_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_messages.h"
+#include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #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 base::DictionaryValue;
+using base::ListValue;
+using base::StringValue;
+using chrome::VersionInfo;
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using extensions::Extension;
+using extensions::Feature;
 
 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))
 
+// 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() {
+  return Feature::GetCurrentChannel() <= 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::kRequestBodyKey, ...);" .
+
+  DictionaryValue* requestBody = new DictionaryValue();
+  out->Set(keys::kRequestBodyKey, requestBody);
+
+  // Get the data presenters, ordered by being interesting.
+  extensions::ChunkedErrorPresenter chunked_error_presenter(request);
+  extensions::RawDataPresenter raw_data_presenter;
+  extensions::ParsedDataPresenter parsed_data_presenter(request);
+  extensions::UploadDataPresenter* const presenters[] = {
+    &chunked_error_presenter,  // First  -- any errors?
+    &parsed_data_presenter,    // Second -- any parseable forms?
+    &raw_data_presenter        // Third  -- any data at all?
+  };
+  // Keys for the results of the corresponding presenters.
+  static const char* const kKeys[] = {
+    keys::kRequestBodyErrorKey,
+    keys::kRequestBodyFormDataKey,
+    keys::kRequestBodyRawKey
+  };
+
+  const std::vector<net::UploadData::Element>* elements =
+      request->get_upload()->elements();
+  bool some_succeeded = false;
+  for (size_t i = 0; !some_succeeded && i < arraysize(presenters); ++i) {
+    std::vector<net::UploadData::Element>::const_iterator element;
+    for (element = elements->begin(); element != elements->end(); ++element) {
+      presenters[i]->FeedNext(*element);
+    }

[battre, 2012/08/16 19:18:03]

nit: no {}

[vabr (Chromium), 2012/08/17 18:29:57]

Done.

+    if (presenters[i]->Succeeded()) {

[battre, 2012/08/16 19:18:03]

This looks wrong to me. Most presenters call Abort() in case they cannot parse
an element but can never back out of this state (Abort() sets an error flag that
is never cleared).

[vabr (Chromium), 2012/08/17 18:29:57]

This is by design, all the elements together represent the input to the parser,
so the parser should be able to parse the whole sequence. Let me please know if
you feel I misunderstood your comment.

[battre, 2012/08/20 12:09:38]

Nevermind, you are right. I misunderstood the loops.

+      requestBody->Set(kKeys[i], presenters[i]->Result().release());
+      some_succeeded = true;
+    }
+  }
+  if (!some_succeeded) {
+    requestBody->SetString(keys::kRequestBodyErrorKey, "Unknown error.");
+  }

[battre, 2012/08/16 19:18:03]

nit: no {}

[vabr (Chromium), 2012/08/17 18:29:57]

Done.

+}
+
 // 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 232 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 == "requestBody")
+      *extra_info_spec |=
+          IsWebRequestBodyDataAccessEnabled() ? REQUEST_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::REQUEST_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 1321 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));
 }