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 118 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 POST data from |request| and writes the data into |out|.
+// This can be expensive, so it's separated from ExtractRequestInfo().
+void ExtractRequestInfoPost(const net::URLRequest* request,
+                            DictionaryValue* out) {
+  if (request->method() != "POST")
+    return;  // Need to exit without "out->Set(keys::kPostDataKey, ...);" .
+
+  DictionaryValue* post_data = new DictionaryValue();
+  out->Set(keys::kPostDataKey, post_data);
+
+  // Chunked encoding (defined in RFC 2616) is currently not supported.
+  std::string transfer_encoding;
+  if (request->extra_request_headers().GetHeader(
+      net::HttpRequestHeaders::kTransferEncoding, &transfer_encoding)) {
+    if (base::strcasecmp(transfer_encoding.c_str(), "chunked") == 0) {
+      post_data->SetString(keys::kPostDataErrorKey, "chunked_encoding");
+      return;
+    }
+  }
+
+  scoped_ptr<DictionaryValue> form_data =
+      extensions::PostDataParser::ParseURLRequestData(request);
+  if (form_data.get() != NULL)
+    post_data->Set(keys::kFormDataKey, form_data.release());
+}
+
 // 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 == "postData")
+      *extra_info_spec |= POST_DATA;
     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::POST_DATA)
+      ExtractRequestInfoPost(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));
 }