Add integration of the new heuristics

components/dom_distiller/core/page_features.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 "components/dom_distiller/core/page_features.h"
 
 #include <string>
 
+#include "base/json/json_reader.h"
 #include "third_party/re2/re2/re2.h"
 
 namespace dom_distiller {
 /* This code needs to derive features in the same way and order in which they
  * are derived when training the model. Parts of that code are reproduced in the
  * comments below.
  */
 
 namespace {
 std::string GetLastSegment(const std::string& path) {
@@ skipping 21 matching lines @@
 bool Contains(const std::string& n, const std::string& h) {
   return h.find(n) != std::string::npos;
 }
 
 bool EndsWith(const std::string& t, const std::string& s) {
   return s.size() >= t.size() &&
          s.compare(s.size() - t.size(), std::string::npos, t) == 0;
 }
 }
 
+int kDerivedFeaturesCount = 29;
+
 std::vector<double> CalculateDerivedFeatures(bool isOGArticle,
                                              const GURL& url,
                                              double numElements,
                                              double numAnchors,
                                              double numForms,
                                              const std::string& innerText,
                                              const std::string& textContent,
                                              const std::string& innerHTML) {
   // In the training pipeline, the strings are explicitly encoded in utf-8 (as
   // they are here).
@@ skipping 65 matching lines @@
   // float(textContentWords) / max(1, innerHTMLWords),
   features.push_back(double(textContentWords) /
                      std::max<int>(1.0, innerHTMLWords));
   // 'innertexttextcontentwordcountratio',
   // float(innerTextWords) / max(1, textContentWords),
   features.push_back(double(innerTextWords) /
                      std::max<int>(1.0, textContentWords));
   return features;
 }
 
-std::vector<double> CalculateDerivedFeaturesFromJSON(const base::Value* json) {
+std::vector<double> CalculateDerivedFeaturesFromJSON(
+    const base::Value* stringified_json) {
+  std::string stringified;
+  if (!stringified_json->GetAsString(&stringified)) {
+    return std::vector<double>();
+  }
+
+  scoped_ptr<base::Value> json(base::JSONReader::Read(stringified));
+  if (!json) {
+    return std::vector<double>();
+  }
+
   const base::DictionaryValue* dict;
   if (!json->GetAsDictionary(&dict)) {
     return std::vector<double>();
   }
 
   bool isOGArticle = false;
   std::string url, innerText, textContent, innerHTML;
   double numElements = 0.0, numAnchors = 0.0, numForms = 0.0;
 
   if (!(dict->GetBoolean("opengraph", &isOGArticle) &&
@@ skipping 10 matching lines @@
   GURL parsed_url(url);
   if (!parsed_url.is_valid()) {
     return std::vector<double>();
   }
 
   return CalculateDerivedFeatures(isOGArticle, parsed_url, numElements,
                                   numAnchors, numForms, innerText, textContent,
                                   innerHTML);
 }
 }