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;
   }
 
-  std::unique_ptr<base::Value> parsed_header = base::JSONReader::Read(header);
+  // 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);
 
   if (!parsed_header) {
-    delegate->AddMessage(current_url, "Expected valid JSON.",
+    delegate->AddMessage(current_url,
+                         "The header's value does not parse as valid JSON.",
                          CONSOLE_MESSAGE_LEVEL_ERROR);
     return false;
   }
 
-  const base::DictionaryValue* dictionary = nullptr;
+  // Expecting a header in the format `"value1", "value2", "value3"`:
   const base::ListValue* types = nullptr;
-  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(parsed_header->GetAsList(&types));
   DCHECK(types);
 
   *clear_cookies = false;
   *clear_storage = false;
   *clear_cache = false;
 
   std::string type_names;
   for (const base::Value& value : *types) {
     std::string type;
-    value.GetAsString(&type);
+    if (value.is_string() && value.GetAsString(&type)) {
+      bool* data_type = nullptr;
 
-    bool* data_type = nullptr;
+      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;
+      }
 
-    if (type == kDatatypeCookies) {
-      data_type = clear_cookies;
-    } else if (type == kDatatypeStorage) {
-      data_type = clear_storage;
-    } else if (type == kDatatypeCache) {
-      data_type = clear_cache;
+      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;
     } 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 in the 'types' field.",
+    delegate->AddMessage(current_url, "No recognized types specified.",
                          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