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"
-#include "components/safe_json/safe_json_parser.h"
 #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"
 
+#if !defined(OS_IOS)
+#include "components/safe_json/safe_json_parser.h"
+#endif
+
 using net::URLFetcher;
 using variations::VariationsService;
 
 namespace {
 
 const char kPopularSitesURLFormat[] =
     "https://www.gstatic.com/chrome/ntp/suggested_sites_%s_%s.json";
 const char kPopularSitesDefaultCountryCode[] = "DEFAULT";
 const char kPopularSitesDefaultVersion[] = "5";
 const char kPopularSitesLocalFilename[] = "suggested_sites.json";
@@ skipping 83 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) {
+    std::string error_msg;
+    int error_line, error_column;
+    std::unique_ptr<base::Value> value = base::JSONReader::ReadAndReturnError(
+        unsafe_json, base::JSON_ALLOW_TRAILING_COMMAS, nullptr, &error_msg,
+        &error_line, &error_column);
+    if (value) {
+      success_callback.Run(std::move(value));
+    } else {
+      error_callback.Run(base::StringPrintf("%s (%d:%d)", error_msg.c_str(),
+                                            error_line, error_column));
+    }
+  }
+};
+
+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);
   }
 }