Add UMA for measuring Content-Dispostion header use and abuse.

net/http/http_content_disposition_unittest.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 "net/http/http_content_disposition.h"
 
 #include "base/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 494 matching lines @@
   };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
     HttpContentDisposition header(tests[i].header, std::string());
     EXPECT_EQ(tests[i].expected_type, header.type())
         << "Failed on input: " << tests[i].header;
     EXPECT_EQ(tests[i].expected_filename, UTF8ToWide(header.filename()))
         << "Failed on input: " << tests[i].header;
   }
 }
 
+TEST(HttpContentDispositionTest, ParseResult) {
+  enum ParseResultFlags {

[rvargas (doing something else), 2012/12/14 22:49:54]

Funny... I was actually thinking that I would have used something like this
instead of 8 bools for the actual interface.

[asanka, 2012/12/15 01:57:32]

Yeah. I changed the interface to use this. :)

[rvargas (doing something else), 2012/12/15 02:46:57]

wow, I was not expecting you to change it.

+    INVALID                      = 0,
+    HAS_DISPOSITION_TYPE         = 1 << 0,
+    HAS_UNKNOWN_DISPOSITION_TYPE = 1 << 1,
+    HAS_NAME                     = 1 << 2,
+    HAS_FILENAME                 = 1 << 3,
+    HAS_EXT_FILENAME             = 1 << 4,
+    HAS_NON_ASCII_STRINGS        = 1 << 5,
+    HAS_PERCENT_ENCODED_STRINGS  = 1 << 6,
+    HAS_RFC2047_ENCODED_STRINGS  = 1 << 7
+  };
+
+  const struct ParseResultTestCase {
+    const char* header;
+    int expected_flags;
+  } kTestCases[] = {
+    // Basic feature tests
+    { "", INVALID },
+    { "example=x", INVALID },
+    { "attachment; filename=", HAS_DISPOSITION_TYPE },
+    { "attachment; name=", HAS_DISPOSITION_TYPE },
+    { "attachment; filename*=", HAS_DISPOSITION_TYPE },
+    { "attachment; filename==?utf-8?Q??=", HAS_DISPOSITION_TYPE },
+    { "filename=x", HAS_FILENAME },
+    { "example; filename=x",
+      HAS_DISPOSITION_TYPE | HAS_UNKNOWN_DISPOSITION_TYPE |
+      HAS_FILENAME},
+    { "attachment; filename=x",
+      HAS_DISPOSITION_TYPE | HAS_FILENAME },
+    { "attachment; filename=x; name=y",
+      HAS_DISPOSITION_TYPE | HAS_FILENAME | HAS_NAME },
+    { "attachment; name=y; filename*=utf-8''foo; name=x",
+      HAS_DISPOSITION_TYPE | HAS_EXT_FILENAME | HAS_NAME },
+
+    // Feature tests for 'filename' attribute.
+    { "filename=foo\xcc\x88",
+      HAS_FILENAME | HAS_NON_ASCII_STRINGS },
+    { "filename=foo%cc%88",
+      HAS_FILENAME | HAS_PERCENT_ENCODED_STRINGS },
+    { "filename==?utf-8?Q?foo?=",
+      HAS_FILENAME | HAS_RFC2047_ENCODED_STRINGS },
+    { "filename=\"=?utf-8?Q?foo?=\"",
+      HAS_FILENAME | HAS_RFC2047_ENCODED_STRINGS },
+    { "filename==?utf-8?Q?foo?", INVALID },
+    { "name=foo\xcc\x88",
+      HAS_NAME },
+
+    // Shouldn't set |has_non_ascii_strings| based on 'name' attribute.
+    { "filename=x; name=foo\xcc\x88",
+      HAS_FILENAME | HAS_NAME },
+    { "filename=foo\xcc\x88 foo%cc%88 =?utf-8?Q?foo?=",
+      HAS_FILENAME | HAS_NON_ASCII_STRINGS | HAS_PERCENT_ENCODED_STRINGS |
+      HAS_RFC2047_ENCODED_STRINGS },
+
+    // If 'filename' attribute is invalid, should set any flags based on it.
+    { "filename=foo\xcc\x88 foo%cc%88 =?utf-8?Q?foo?",
+      INVALID },
+    { "filename=foo\xcc\x88 foo%cc%88 =?utf-8?Q?foo?; name=x",
+      HAS_NAME },
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestCases); ++i) {
+    const ParseResultTestCase& test_case = kTestCases[i];
+    HttpContentDisposition content_disposition(test_case.header, "utf-8");
+    const HttpContentDisposition::ParseResult& result =
+        content_disposition.parse_result();
+
+    SCOPED_TRACE(testing::Message() << "Test case " << i
+                                    << " with header " << test_case.header);
+
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_DISPOSITION_TYPE),
+              result.has_disposition_type);
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_UNKNOWN_DISPOSITION_TYPE),
+              result.has_unknown_disposition_type);
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_NAME),
+              result.has_name);
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_FILENAME),
+              result.has_filename);
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_EXT_FILENAME),
+              result.has_ext_filename);
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_NON_ASCII_STRINGS),
+              result.has_non_ascii_strings);
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_PERCENT_ENCODED_STRINGS),
+              result.has_percent_encoded_strings);
+    EXPECT_EQ(!!(test_case.expected_flags & HAS_RFC2047_ENCODED_STRINGS),
+              result.has_rfc2047_encoded_strings);
+  }
+}
+
 }  // namespace net