Remove use of WebNode/WebElement in translate_helper

components/translate/content/renderer/translate_helper.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 "components/translate/content/renderer/translate_helper.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_metrics.h"
 #include "components/translate/core/common/translate_util.h"
 #include "components/translate/core/language_detection/language_detection_util.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
-#include "third_party/WebKit/public/web/WebElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
-#include "third_party/WebKit/public/web/WebNode.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "url/gurl.h"
 #include "v8/include/v8.h"
 
 using base::ASCIIToUTF16;
 using blink::WebDocument;
-using blink::WebElement;
 using blink::WebLocalFrame;
-using blink::WebNode;
 using blink::WebScriptSource;
 using blink::WebSecurityOrigin;
 using blink::WebString;
 using blink::WebVector;
 
 namespace {
 
 // The delay in milliseconds that we'll wait before checking to see if the
 // translate library injected in the page is ready.
 const int kTranslateInitCheckDelayMs = 150;
 
 // The maximum number of times we'll check to see if the translate library
 // injected in the page is ready.
 const int kMaxTranslateInitCheckAttempts = 5;
 
 // The delay we wait in milliseconds before checking whether the translation has
 // finished.
 const int kTranslateStatusCheckDelayMs = 400;
 
 // Language name passed to the Translate element for it to detect the language.
 const char kAutoDetectionLanguage[] = "auto";
 
 // Isolated world sets following content-security-policy.
 const char kContentSecurityPolicy[] = "script-src 'self' 'unsafe-eval'";
 
 // Returns whether the page associated with |document| is a candidate for
 // translation.  Some pages can explictly specify (via a meta-tag) that they
 // should not be translated.
 // TODO(dglazkov): This logic should be moved into Blink.

[jbroman, 2016/12/16 16:17:42]

I think this CL fixes what this comment as looking for, in which case the TODO
can be removed.

[adithyas, 2016/12/16 21:57:17]

Done.

 bool HasNoTranslateMeta(WebDocument* document) {
-  WebElement head = document->head();
-  if (head.isNull() || head.firstChild().isNull())
-    return false;
-
-  const WebString meta(ASCIIToUTF16("meta"));
-  const WebString name(ASCIIToUTF16("name"));
-  const WebString google(ASCIIToUTF16("google"));
-  const WebString value(ASCIIToUTF16("value"));
-  const WebString content(ASCIIToUTF16("content"));
-
-  for (WebNode child = head.firstChild(); !child.isNull();
-       child = child.nextSibling()) {
-    if (!child.isElementNode())
-      continue;
-    WebElement element = child.to<WebElement>();
-    // Check if a tag is <meta>.
-    if (!element.hasHTMLTagName(meta))
-      continue;
-    // Check if the tag contains name="google".
-    WebString attribute = element.getAttribute(name);
-    if (attribute.isNull() || attribute != google)
-      continue;
-    // Check if the tag contains value="notranslate", or content="notranslate".
-    attribute = element.getAttribute(value);
-    if (attribute.isNull())
-      attribute = element.getAttribute(content);
-    if (attribute.isNull())
-      continue;
-    if (base::LowerCaseEqualsASCII(base::StringPiece16(attribute),
-                                   "notranslate"))
+  WebVector<WebString> values = document->getMetaValues(ASCIIToUTF16("google"));

[jbroman, 2016/12/16 16:17:42]

super-nit: ASCIIToUTF16 shouldn't be necessary here. I think the converting
constructor from char arrays (which takes UTF-8) should be triggered
automatically. Ideally we would have an overload of WebString::fromASCII that
took a string literal.

[adithyas, 2016/12/16 21:57:17]

Okay, changed it.

+  for (auto value : values) {

[jbroman, 2016/12/16 16:17:42]

nit: this unnecessarily copies WebString (which results in ref count changes);
use "const auto&" or "const WebString&".

Alternatively, you could use <algorithm>, like so:

return std::any_of(values.begin(), values.end(),
    [](const WebString& value) {
        return base::LowerCaseEqualsASCII(base::StringPiece16(value),
"notranslate");
    });

[adithyas, 2016/12/16 21:57:17]

Changed to use a const reference and any_of.

+    if (base::LowerCaseEqualsASCII(base::StringPiece16(value), "notranslate"))
       return true;
   }
   return false;
 }
 
 }  // namespace
 
 namespace translate {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 26 matching lines @@
   // being the language of the document and the latter being the
   // language of the intended audience (a distinction really only
   // relevant for things like langauge textbooks).  This distinction
   // shouldn't affect translation.
   WebLocalFrame* main_frame = render_frame()->GetWebFrame();
   if (!main_frame)
     return;
 
   WebDocument document = main_frame->document();
   std::string content_language = document.contentLanguage().utf8();
-  WebElement html_element = document.documentElement();
-  std::string html_lang;
-  // |html_element| can be null element, e.g. in
-  // BrowserTest.WindowOpenClose.
-  if (!html_element.isNull())
-    html_lang = html_element.getAttribute("lang").utf8();
+  std::string html_lang = document.documentLanguage().utf8();
   std::string cld_language;
   bool is_cld_reliable;
   std::string language = DeterminePageLanguage(
       content_language, html_lang, contents, &cld_language, &is_cld_reliable);
 
   if (language.empty())
     return;
 
   language_determined_time_ = base::TimeTicks::Now();
 
@@ skipping 313 matching lines @@
   binding_.Close();
   translate_callback_pending_.Reset();
   CancelPendingTranslation();
 }
 
 void TranslateHelper::OnDestruct() {
   delete this;
 }
 
 }  // namespace translate