Parse PopularSites JSON on iOS too.

chrome/browser/android/ntp/popular_sites.cc

 // Copyright 2015 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 "chrome/browser/android/ntp/popular_sites.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/common/chrome_paths.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/ntp_tiles/pref_names.h"
 #include "components/ntp_tiles/switches.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
+#if !defined(OS_IOS)

[Marc Treib, 2016/06/07 09:03:07]

This should go in a separate block, below the non-OS-dependent includes.

[sfiera, 2016/06/07 12:43:52]

Done.

 #include "components/safe_json/safe_json_parser.h"
+#endif
 #include "components/search_engines/search_engine_type.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/service/variations_service.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 
 using net::URLFetcher;
 using variations::VariationsService;
 
@@ skipping 90 matching lines @@
 
 // Must run on the blocking thread pool.
 bool WriteJsonToFile(const base::FilePath& local_path,
                      const base::Value* json) {
   std::string json_string;
   return base::JSONWriter::Write(*json, &json_string) &&
          base::ImportantFileWriter::WriteFileAtomically(local_path,
                                                         json_string);
 }
 
+#if defined(OS_IOS)
+// Mimics SafeJsonParser API, but parses unsafely for iOS.
+class JsonUnsafeParser {
+ public:
+  using SuccessCallback = base::Callback<void(std::unique_ptr<base::Value>)>;
+  using ErrorCallback = base::Callback<void(const std::string&)>;
+
+  // As with SafeJsonParser, runs either success_callback or error_callback on
+  // the calling thread, but not before the call returns.
+  static void Parse(const std::string& unsafe_json,
+                    const SuccessCallback& success_callback,
+                    const ErrorCallback& error_callback) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(DoParse, unsafe_json, success_callback, error_callback));
+  }
+
+  JsonUnsafeParser() = delete;
+
+ private:
+  static void DoParse(const std::string& unsafe_json,
+                      const SuccessCallback& success_callback,
+                      const ErrorCallback& error_callback) {
+    auto value =

[Marc Treib, 2016/06/07 09:03:07]

Use the actual type please

[sfiera, 2016/06/07 12:43:52]

Done.

+        base::JSONReader::Read(unsafe_json, base::JSON_ALLOW_TRAILING_COMMAS);
+    if (value) {
+      success_callback.Run(std::move(value));
+    } else {
+      error_callback.Run("JSON parsing failed");

[Marc Treib, 2016/06/07 09:03:07]

JSONReader has a ReadAndReturnError, maybe use that to get a more useful error
message?

[sfiera, 2016/06/07 12:43:52]

Done.

+    }
+  }
+};
+
+using UntrustedJsonParser = JsonUnsafeParser;
+#else
+using UntrustedJsonParser = safe_json::SafeJsonParser;
+#endif
+
 }  // namespace
 
 base::FilePath ChromePopularSites::GetDirectory() {
   base::FilePath dir;
   PathService::Get(chrome::DIR_USER_DATA, &dir);
   return dir;  // empty if PathService::Get() failed.
 }
 
 PopularSites::Site::Site(const base::string16& title,
                          const GURL& url,
@@ skipping 169 matching lines @@
   std::unique_ptr<net::URLFetcher> free_fetcher = std::move(fetcher_);
 
   std::string json_string;
   if (!(source->GetStatus().is_success() &&
         source->GetResponseCode() == net::HTTP_OK &&
         source->GetResponseAsString(&json_string))) {
     OnDownloadFailed();
     return;
   }
 
-  safe_json::SafeJsonParser::Parse(
+  UntrustedJsonParser::Parse(
       json_string,
       base::Bind(&PopularSites::OnJsonParsed, weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&PopularSites::OnJsonParseFailed,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PopularSites::OnJsonParsed(std::unique_ptr<base::Value> json) {
   const base::Value* json_ptr = json.get();
   base::PostTaskAndReplyWithResult(
       blocking_runner_.get(), FROM_HERE,
@@ skipping 61 matching lines @@
     DLOG(WARNING) << "Download country site list failed";
     is_fallback_ = true;
     pending_country_ = kPopularSitesDefaultCountryCode;
     pending_version_ = kPopularSitesDefaultVersion;
     FetchPopularSites(GetPopularSitesURL());
   } else {
     DLOG(WARNING) << "Download fallback site list failed";
     callback_.Run(false);
   }
 }