Translate: infobars should not appear when a page has a refresh meta tag

chrome/renderer/chrome_render_view_observer.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 "chrome/renderer/chrome_render_view_observer.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
-#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/prerender_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/chrome_render_process_observer.h"
 #include "chrome/renderer/content_settings_observer.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "chrome/renderer/external_host_bindings.h"
 #include "chrome/renderer/frame_sniffer.h"
 #include "chrome/renderer/prerender/prerender_helper.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
 #include "chrome/renderer/translate/translate_helper.h"
 #include "chrome/renderer/webview_color_overlay.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/common/constants.h"
 #include "net/base/data_url.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURLRequest.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebVector.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebAccessibilityObject.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebNode.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebNodeList.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/size.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "v8/include/v8-testing.h"
 #include "webkit/glue/image_decoder.h"
 #include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebAccessibilityObject;
 using WebKit::WebCString;
 using WebKit::WebDataSource;
 using WebKit::WebDocument;
+using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebGestureEvent;
 using WebKit::WebIconURL;
+using WebKit::WebNode;
+using WebKit::WebNodeList;
 using WebKit::WebRect;
 using WebKit::WebSecurityOrigin;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebTouchEvent;
 using WebKit::WebURL;
 using WebKit::WebURLRequest;
 using WebKit::WebView;
 using WebKit::WebVector;
 using extensions::APIPermission;
@@ skipping 344 matching lines @@
 
 bool ChromeRenderViewObserver::allowWriteToClipboard(WebFrame* frame,
                                                     bool default_value) {
   bool allowed = false;
   Send(new ChromeViewHostMsg_CanTriggerClipboardWrite(
       routing_id(), GURL(frame->document().securityOrigin().toString().utf8()),
       &allowed));
   return allowed;
 }
 
-const extensions::Extension* ChromeRenderViewObserver::GetExtension(
-    const WebSecurityOrigin& origin) const {
-  if (!EqualsASCII(origin.protocol(), extensions::kExtensionScheme))
-    return NULL;
-
-  const std::string extension_id = origin.host().utf8().data();
-  if (!extension_dispatcher_->IsExtensionActive(extension_id))
-    return NULL;
-
-  return extension_dispatcher_->extensions()->GetByID(extension_id);
-}
-
 bool ChromeRenderViewObserver::allowWebComponents(const WebDocument& document,
                                                   bool defaultValue) {
   if (defaultValue)
     return true;
 
   WebSecurityOrigin origin = document.securityOrigin();
   if (EqualsASCII(origin.protocol(), chrome::kChromeUIScheme))
     return true;
 
   if (const extensions::Extension* extension = GetExtension(origin)) {
@@ skipping 181 matching lines @@
       webui_javascript_.get()) {
     render_view()->EvaluateScript(webui_javascript_->frame_xpath,
                                   webui_javascript_->jscript,
                                   webui_javascript_->id,
                                   webui_javascript_->notify_result);
     webui_javascript_.reset();
   }
 }
 
 void ChromeRenderViewObserver::DidStopLoading() {
-  CapturePageInfoLater(
-      false,  // preliminary_capture
-      base::TimeDelta::FromMilliseconds(
-          render_view()->GetContentStateImmediately() ?
-              0 : kDelayForCaptureMs));
-
   WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   GURL osd_url = main_frame->document().openSearchDescriptionURL();
   if (!osd_url.is_empty()) {
     Send(new ChromeViewHostMsg_PageHasOSDD(
         routing_id(), render_view()->GetPageId(), osd_url,
         search_provider::AUTODETECTED_PROVIDER));
   }
+
+  // Don't capture pages including refresh meta tag.
+  if (HasRefreshMetaTag(main_frame))
+    return;
+
+  CapturePageInfoLater(
+      render_view()->GetPageId(),
+      false,  // preliminary_capture
+      base::TimeDelta::FromMilliseconds(
+          render_view()->GetContentStateImmediately() ?
+              0 : kDelayForCaptureMs));
 }
 
 void ChromeRenderViewObserver::DidCommitProvisionalLoad(
     WebFrame* frame, bool is_new_navigation) {
-  if (!is_new_navigation)
+  // Don't capture pages being not new, or including refresh meta tag.
+  if (!is_new_navigation || HasRefreshMetaTag(frame))
     return;
 
   CapturePageInfoLater(
+      render_view()->GetPageId(),
       true,  // preliminary_capture
       base::TimeDelta::FromMilliseconds(kDelayForForcedCaptureMs));
 }
 
 void ChromeRenderViewObserver::DidClearWindowObject(WebFrame* frame) {
   if (render_view()->GetEnabledBindings() &
           content::BINDINGS_POLICY_EXTERNAL_HOST) {
     GetExternalHostBindings()->BindToJavascript(frame, "externalHost");
   }
 }
 
 void ChromeRenderViewObserver::DidHandleGestureEvent(
     const WebGestureEvent& event) {
   if (event.type != WebKit::WebGestureEvent::GestureTap)
     return;
 
   WebKit::WebTextInputType text_input_type =
       render_view()->GetWebView()->textInputType();
 
   render_view()->Send(new ChromeViewHostMsg_FocusedNodeTouched(
       routing_id(),
       text_input_type != WebKit::WebTextInputTypeNone));
 }
 
-void ChromeRenderViewObserver::CapturePageInfoLater(bool preliminary_capture,
+void ChromeRenderViewObserver::CapturePageInfoLater(int page_id,
+                                                    bool preliminary_capture,
                                                     base::TimeDelta delay) {
   capture_timer_.Start(
       FROM_HERE,
       delay,
       base::Bind(&ChromeRenderViewObserver::CapturePageInfo,
                  base::Unretained(this),
+                 page_id,
                  preliminary_capture));
 }
 
-void ChromeRenderViewObserver::CapturePageInfo(bool preliminary_capture) {
-  int page_id = render_view()->GetPageId();
+void ChromeRenderViewObserver::CapturePageInfo(int page_id,
+                                               bool preliminary_capture) {
+  // If |page_id| is obsolete, we should stop indexing and capturing a page.
+  if (render_view()->GetPageId() != page_id)
+    return;
 
   if (!render_view()->GetWebView())
     return;
 
   WebFrame* main_frame = render_view()->GetWebView()->mainFrame();
   if (!main_frame)
     return;
 
   // Don't index/capture pages that are in view source mode.
   if (main_frame->isViewSourceModeEnabled())
@@ skipping 102 matching lines @@
   if (!external_host_bindings_.get()) {
     external_host_bindings_.reset(new ExternalHostBindings(
         render_view(), routing_id()));
   }
   return external_host_bindings_.get();
 }
 
 bool ChromeRenderViewObserver::IsStrictSecurityHost(const std::string& host) {
   return (strict_security_hosts_.find(host) != strict_security_hosts_.end());
 }
+
+const extensions::Extension* ChromeRenderViewObserver::GetExtension(
+    const WebSecurityOrigin& origin) const {
+  if (!EqualsASCII(origin.protocol(), extensions::kExtensionScheme))
+    return NULL;
+
+  const std::string extension_id = origin.host().utf8().data();
+  if (!extension_dispatcher_->IsExtensionActive(extension_id))
+    return NULL;
+
+  return extension_dispatcher_->extensions()->GetByID(extension_id);
+}
+
+bool ChromeRenderViewObserver::HasRefreshMetaTag(WebFrame* frame) {
+  if (!frame)
+    return false;
+  WebElement head = frame->document().head();
+  if (head.isNull() || !head.hasChildNodes())
+    return false;
+
+  const WebString tag_name(ASCIIToUTF16("meta"));
+  const WebString attribute_name(ASCIIToUTF16("http-equiv"));
+  const WebString attribute_value(ASCIIToUTF16("refresh"));
+
+  WebNodeList children = head.childNodes();
+  for (size_t i = 0; i < children.length(); ++i) {
+    WebNode node = children.item(i);
+    if (!node.isElementNode())
+      continue;
+    WebElement element = node.to<WebElement>();
+    if (!element.hasTagName(tag_name))
+      continue;
+    WebString value = element.getAttribute(attribute_name);
+    if (value.isNull() || value != attribute_value)
+      continue;
+    return true;
+  }
+  return false;
+}