Revert of Align `clear-site-data` syntax with the spec.

content/browser/browsing_data/clear_site_data_throttle.cc

 // Copyright 2016 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 "content/browser/browsing_data/clear_site_data_throttle.h"
 
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 19 matching lines @@
 #include "url/origin.h"
 
 namespace content {
 
 namespace {
 
 const char kNameForLogging[] = "ClearSiteDataThrottle";
 
 const char kClearSiteDataHeader[] = "Clear-Site-Data";
 
+const char kTypesKey[] = "types";
+
 // Datatypes.
 const char kDatatypeCookies[] = "cookies";
 const char kDatatypeStorage[] = "storage";
 const char kDatatypeCache[] = "cache";
 
 // Pretty-printed log output.
 const char kConsoleMessageTemplate[] = "Clear-Site-Data header on '%s': %s";
 const char kConsoleMessageCleared[] = "Cleared data types: %s.";
 const char kConsoleMessageDatatypeSeparator[] = ", ";
 
@@ skipping 387 matching lines @@
                                         bool* clear_storage,
                                         bool* clear_cache,
                                         ConsoleMessagesDelegate* delegate,
                                         const GURL& current_url) {
   if (!base::IsStringASCII(header)) {
     delegate->AddMessage(current_url, "Must only contain ASCII characters.",
                          CONSOLE_MESSAGE_LEVEL_ERROR);
     return false;
   }
 
-  // Wrap |header| in `[` and `]`, then process it as a JSON array:
-  //
-  // TODO(mkwst): Drop the JSONReader bits in favor of a simpler parser.
-  std::string wrapped = "[" + header + "]";
-  std::unique_ptr<base::Value> parsed_header = base::JSONReader::Read(wrapped);
+  std::unique_ptr<base::Value> parsed_header = base::JSONReader::Read(header);
 
   if (!parsed_header) {
-    delegate->AddMessage(current_url,
-                         "The header's value does not parse as valid JSON.",
+    delegate->AddMessage(current_url, "Expected valid JSON.",
                          CONSOLE_MESSAGE_LEVEL_ERROR);
     return false;
   }
 
-  // Expecting a header in the format `"value1", "value2", "value3"`:
+  const base::DictionaryValue* dictionary = nullptr;
   const base::ListValue* types = nullptr;
-  DCHECK(parsed_header->GetAsList(&types));
+  if (!parsed_header->GetAsDictionary(&dictionary) ||
+      !dictionary->GetListWithoutPathExpansion(kTypesKey, &types)) {
+    delegate->AddMessage(current_url,
+                         "Expected a JSON dictionary with a 'types' field.",
+                         CONSOLE_MESSAGE_LEVEL_ERROR);
+    return false;
+  }
+
   DCHECK(types);
 
   *clear_cookies = false;
   *clear_storage = false;
   *clear_cache = false;
 
   std::string type_names;
   for (const base::Value& value : *types) {
     std::string type;
-    if (value.is_string() && value.GetAsString(&type)) {
-      bool* data_type = nullptr;
+    value.GetAsString(&type);
 
-      if (type == kDatatypeCookies) {
-        data_type = clear_cookies;
-      } else if (type == kDatatypeStorage) {
-        data_type = clear_storage;
-      } else if (type == kDatatypeCache) {
-        data_type = clear_cache;
-      } else {
-        delegate->AddMessage(
-            current_url,
-            base::StringPrintf("Unrecognized type: \"%s\".", type.c_str()),
-            CONSOLE_MESSAGE_LEVEL_ERROR);
-        continue;
-      }
+    bool* data_type = nullptr;
 
-      DCHECK(data_type);
-
-      // Each data type should only be processed once.
-      if (*data_type)
-        continue;
-
-      *data_type = true;
-      if (!type_names.empty())
-        type_names += kConsoleMessageDatatypeSeparator;
-      type_names += type;
+    if (type == kDatatypeCookies) {
+      data_type = clear_cookies;
+    } else if (type == kDatatypeStorage) {
+      data_type = clear_storage;
+    } else if (type == kDatatypeCache) {
+      data_type = clear_cache;
     } else {
       std::string serialized_type;
       JSONStringValueSerializer serializer(&serialized_type);
       serializer.Serialize(value);
       delegate->AddMessage(
           current_url,
           base::StringPrintf("Unrecognized type: %s.", serialized_type.c_str()),
           CONSOLE_MESSAGE_LEVEL_ERROR);
+      continue;
     }
+
+    DCHECK(data_type);
+
+    // Each data type should only be processed once.
+    if (*data_type)
+      continue;
+
+    *data_type = true;
+    if (!type_names.empty())
+      type_names += kConsoleMessageDatatypeSeparator;
+    type_names += type;
   }
 
   if (!*clear_cookies && !*clear_storage && !*clear_cache) {
-    delegate->AddMessage(current_url, "No recognized types specified.",
+    delegate->AddMessage(current_url,
+                         "No recognized types specified in the 'types' field.",
                          CONSOLE_MESSAGE_LEVEL_ERROR);
     return false;
   }
 
   // Pretty-print which types are to be cleared.
   delegate->AddMessage(
       current_url,
       base::StringPrintf(kConsoleMessageCleared, type_names.c_str()),
       CONSOLE_MESSAGE_LEVEL_INFO);
 
@@ skipping 31 matching lines @@
   Resume();
 }
 
 void ClearSiteDataThrottle::OutputConsoleMessages() {
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
   if (info)
     delegate_->OutputMessages(info->GetWebContentsGetterForRequest());
 }
 
 }  // namespace content