Parse manifest file with app.service_worker.script.

base/test/values_test_util.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 "base/test/values_test_util.h"
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 56 matching lines @@
   scoped_ptr<Value> result(base::JSONReader::ReadAndReturnError(
       json, base::JSON_ALLOW_TRAILING_COMMAS,
       NULL, &error_msg));
   if (!result) {
     ADD_FAILURE() << "Failed to parse \"" << json << "\": " << error_msg;
     result.reset(Value::CreateNullValue());
   }
   return result.Pass();
 }
 
+scoped_ptr<DictionaryValue> ParseJsonDictionaryWithSingleQuotes(

[Paweł Hajdan Jr., 2014/03/03 22:50:47]

Why not let the caller do things this code is doing?

[scheib, 2014/03/03 22:56:43]

To avoid code duplication and increase test readability. See 
https://codereview.chromium.org/178253007/diff/160001/chrome/common/extension...

[not at google - send to devlin, 2014/03/03 22:59:04]

FWIW this is a function I've also often very much wanted but never had the
motivation to write, so, thank you Vincent. Extensions tests often involve
writing a lot of JSON (most notably manifests), and it's super painful and
unreadable to be escaping all the time. We could have this be extensions-only
but I think it would be a shame.

[Paweł Hajdan Jr., 2014/03/05 03:52:56]

Extracting this to a function is fine. Having that function in base is
non-obvious.

[scheib, 2014/03/05 04:49:41]

Fair point. Here's my justification: It is highly related to the other Value
related test utilities already here in base. Parsing a dictionary from text in
tests is likely to come up in many scenarios. I first started writing the util
in an extensions folder, but it really has nothing specific to it related to
extensions. I've had previous desire when dealing with dictionaries of cached
settings for a function like this as well. So I promoted it here to
base::test::.

I'll pull it out to just extensions if you think this is the wrong judgment
call.

+    base::StringPiece json) {
+  std::string json_single_quotes_replaced = json.as_string();

[Jeffrey Yasskin, 2014/03/04 01:41:48]

Since you're making a copy here anyway, you should probably take a std::string
by value instead of the StringPiece.

[scheib, 2014/03/04 15:34:31]

Done.

+  std::replace(json_single_quotes_replaced.begin(),
+               json_single_quotes_replaced.end(),
+               '\'',
+               '"');
+  std::string error_msg;
+  scoped_ptr<Value> result(
+      base::JSONReader::ReadAndReturnError(json_single_quotes_replaced,
+                                           base::JSON_ALLOW_TRAILING_COMMAS,
+                                           NULL,
+                                           &error_msg));
+  scoped_ptr<base::DictionaryValue> result_dict;
+  if (result && result->IsType(base::Value::TYPE_DICTIONARY)) {
+    result_dict.reset(static_cast<DictionaryValue*>(result.release()));
+  } else {
+    ADD_FAILURE() << "Failed to parse \"" << json << "\": " << error_msg;
+    result_dict.reset(new base::DictionaryValue());
+  }
+  return result_dict.Pass();
+}
+
 }  // namespace test
 }  // namespace base