Make JSONParser a pure interface.

components/safe_json/safe_json_parser.h

 // Copyright 2013 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.
 
 #ifndef COMPONENTS_SAFE_JSON_SAFE_JSON_PARSER_H_
 #define COMPONENTS_SAFE_JSON_SAFE_JSON_PARSER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
-#include "content/public/browser/utility_process_host_client.h"
 
 namespace base {
-class ListValue;
-class SingleThreadTaskRunner;
 class Value;
 }
 
-namespace IPC {
-class Message;
-}
-
 namespace safe_json {
 
-// SafeJsonParser parses a given JSON safely via a utility process. The object
-// is ref-counted and kept alive after Start() is called until one of the two
-// callbacks is called.
-class SafeJsonParser : public content::UtilityProcessHostClient {
+// SafeJsonParser parses a given JSON safely via a platform-dependent mechanism
+// (like parsing it in a utility process or in a memory-safe environment).
+// The object is kept alive after Start() is called until one of the two
+// callbacks is called, after which it will delete itself.
+class SafeJsonParser {
  public:
-  typedef base::Callback<void(scoped_ptr<base::Value>)> SuccessCallback;
-  typedef base::Callback<void(const std::string&)> ErrorCallback;
+  using SuccessCallback = base::Callback<void(scoped_ptr<base::Value>)>;
+  using ErrorCallback = base::Callback<void(const std::string&)>;
 
-  SafeJsonParser(const std::string& unsafe_json,
-                 const SuccessCallback& success_callback,
-                 const ErrorCallback& error_callback);
+  using Factory = SafeJsonParser* (*)(const std::string& unsafe_json,
+                                      const SuccessCallback& success_callback,
+                                      const ErrorCallback& error_callback);
 
-  void Start();
+  static SafeJsonParser* Create(const std::string& unsafe_json,

[Robert Sesek, 2015/07/01 22:19:04]

At minium, ditto the comment about ownership here.

But it seems like there's no point in separating Create() from Start() anymore.
And APIs that return pointers without explicit ownership make it hard to reason
about lifetimes. Could Create() just call Start() internally and return void
(and renamed to Parse() or something)?

[Bernhard Bauer, 2015/07/02 14:16:01]

Done.

I also moved the Impl class to a separate file, to allow sharing the static code
between different implementations.

+                               const SuccessCallback& success_callback,

[Robert Sesek, 2015/07/01 22:19:04]

nit: alignment

[Bernhard Bauer, 2015/07/02 14:16:01]

Done.

+                               const ErrorCallback& error_callback);
 
- private:
-  ~SafeJsonParser() override;
+  virtual void Start() = 0;
 
-  void StartWorkOnIOThread();
+  static void SetFactoryForTesting(Factory factory);
 
-  void OnJSONParseSucceeded(const base::ListValue& wrapper);
-  void OnJSONParseFailed(const std::string& error_message);
-
-  void ReportResults();
-  void ReportResultsOnOriginThread();
-
-  // Implementing pieces of the UtilityProcessHostClient interface.
-  bool OnMessageReceived(const IPC::Message& message) override;
-
-  const std::string unsafe_json_;
-  SuccessCallback success_callback_;
-  ErrorCallback error_callback_;
-  scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
-
-  scoped_ptr<base::Value> parsed_json_;
-  std::string error_;
-
-  DISALLOW_COPY_AND_ASSIGN(SafeJsonParser);
+ protected:
+  virtual ~SafeJsonParser() {}
 };
 
 }  // namespace safe_json
 
 #endif  // COMPONENTS_SAFE_JSON_SAFE_JSON_PARSER_H_