Update to Chromium revision 167921.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@907 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

CHROMIUM_BUILD_COMPATIBILITY.txt

@@ -17,5 +17,5 @@
 
 {
   'chromium_url': 'http://src.chromium.org/svn/trunk/src',
-  'chromium_revision': '165669',
+  'chromium_revision': '167921',
 }

include/internal/cef_types.h

@@ -130,7 +130,8 @@ enum cef_log_severity_t {
 
 ///
 // Initialization settings. Specify NULL or 0 to get the recommended default
-// values.
+// values. Many of these and other settings can also configured using command-
+// line flags.
 ///
 typedef struct _cef_settings_t {
   ///
@@ -284,7 +285,8 @@ typedef struct _cef_settings_t {
 ///
 // Browser initialization settings. Specify NULL or 0 to get the recommended
 // default values. The consequences of using custom values may not be well
-// tested.
+// tested. Many of these and other settings can also configured using command-
+// line flags.
 ///
 typedef struct _cef_browser_settings_t {
   ///
@@ -479,16 +481,6 @@ typedef struct _cef_browser_settings_t {
   ///
   bool accelerated_2d_canvas_disabled;
 
-  ///
-  // Set to true (1) to enable accelerated painting.
-  ///
-  bool accelerated_painting_enabled;
-
-  ///
-  // Set to true (1) to enable accelerated filters.
-  ///
-  bool accelerated_filters_enabled;
-
   ///
   // Set to true (1) to disable accelerated plugins.
   ///
@@ -498,11 +490,6 @@ typedef struct _cef_browser_settings_t {
   // Set to true (1) to disable developer tools (WebKit inspector).
   ///
   bool developer_tools_disabled;
-
-  ///
-  // Set to true (1) to enable fullscreen mode.
-  ///
-  bool fullscreen_enabled;
 } cef_browser_settings_t;
 
 ///

include/internal/cef_types_wrappers.h

@@ -398,11 +398,8 @@ struct CefBrowserSettingsTraits {
     target->accelerated_video_disabled = src->accelerated_video_disabled;
     target->accelerated_2d_canvas_disabled =
         src->accelerated_2d_canvas_disabled;
-    target->accelerated_painting_enabled = src->accelerated_painting_enabled;
-    target->accelerated_filters_enabled = src->accelerated_filters_enabled;
     target->accelerated_plugins_disabled = src->accelerated_plugins_disabled;
     target->developer_tools_disabled = src->developer_tools_disabled;
-    target->fullscreen_enabled = src->fullscreen_enabled;
   }
 };
 
@@ -503,8 +500,8 @@ class CefTime : public CefStructBase<CefTimeTraits> {
   }
 
   // Return the delta between this object and |other| in milliseconds.
-  int64 Delta(const CefTime& other) {
-    int64 delta = 0;
+  long long Delta(const CefTime& other) {
+    long long delta = 0;
     cef_time_delta(this, &other, &delta);
     return delta;
   }

libcef/browser/browser_settings.cc

@@ -7,184 +7,125 @@
 #include <string>
 
 #include "include/internal/cef_types_wrappers.h"
-
-#include "base/file_path.h"
-#include "base/utf_string_conversions.h"
-#include "content/browser/gpu/gpu_process_host.h"
-#include "content/public/browser/gpu_data_manager.h"
 #include "webkit/glue/webpreferences.h"
 
 using webkit_glue::WebPreferences;
 
+// Use the preferences from WebContentsImpl::GetWebkitPrefs and the
+// WebPreferences constructor by default. Only override features that are
+// explicitly enabled or disabled.
 void BrowserToWebSettings(const CefBrowserSettings& cef, WebPreferences& web) {
   if (cef.standard_font_family.length > 0) {
     web.standard_font_family_map[WebPreferences::kCommonScript] =
         CefString(&cef.standard_font_family);
-  } else {
-    web.standard_font_family_map[WebPreferences::kCommonScript] =
-        ASCIIToUTF16("Times");
   }
-
   if (cef.fixed_font_family.length > 0) {
     web.fixed_font_family_map[WebPreferences::kCommonScript] =
         CefString(&cef.fixed_font_family);
-  } else {
-    web.fixed_font_family_map[WebPreferences::kCommonScript] =
-        ASCIIToUTF16("Courier");
   }
-
   if (cef.serif_font_family.length > 0) {
     web.serif_font_family_map[WebPreferences::kCommonScript] =
         CefString(&cef.serif_font_family);
-  } else {
-    web.serif_font_family_map[WebPreferences::kCommonScript] =
-        ASCIIToUTF16("Times");
   }
-
   if (cef.sans_serif_font_family.length > 0) {
     web.sans_serif_font_family_map[WebPreferences::kCommonScript] =
         CefString(&cef.sans_serif_font_family);
-  } else {
-    web.sans_serif_font_family_map[WebPreferences::kCommonScript] =
-        ASCIIToUTF16("Helvetica");
   }
-
-  // These two fonts below are picked from the intersection of
-  // Win XP font list and Vista font list :
-  //   http://www.microsoft.com/typography/fonts/winxp.htm
-  //   http://blogs.msdn.com/michkap/archive/2006/04/04/567881.aspx
-  // Some of them are installed only with CJK and complex script
-  // support enabled on Windows XP and are out of consideration here.
-  // (although we enabled both on our buildbots.)
-  // They (especially Impact for fantasy) are not typical cursive
-  // and fantasy fonts, but it should not matter for layout tests
-  // as long as they're available.
-
   if (cef.cursive_font_family.length > 0) {
     web.cursive_font_family_map[WebPreferences::kCommonScript] =
         CefString(&cef.cursive_font_family);
-  } else {
-    web.cursive_font_family_map[WebPreferences::kCommonScript] =
-#if defined(OS_MACOSX)
-        ASCIIToUTF16("Apple Chancery");
-#else
-        ASCIIToUTF16("Comic Sans MS");
-#endif
   }
-
   if (cef.fantasy_font_family.length > 0) {
     web.fantasy_font_family_map[WebPreferences::kCommonScript] =
         CefString(&cef.fantasy_font_family);
-  } else {
-    web.fantasy_font_family_map[WebPreferences::kCommonScript] =
-#if defined(OS_MACOSX)
-        ASCIIToUTF16("Papyrus");
-#else
-        ASCIIToUTF16("Impact");
-#endif
   }
 
   if (cef.default_font_size > 0)
     web.default_font_size = cef.default_font_size;
-  else
-    web.default_font_size = 16;
-
   if (cef.default_fixed_font_size > 0)
     web.default_fixed_font_size = cef.default_fixed_font_size;
-  else
-    web.default_fixed_font_size = 13;
-
   if (cef.minimum_font_size > 0)
     web.minimum_font_size = cef.minimum_font_size;
-  else
-    web.minimum_font_size = 1;
-
   if (cef.minimum_logical_font_size > 0)
     web.minimum_logical_font_size = cef.minimum_logical_font_size;
-  else
-    web.minimum_logical_font_size = 9;
-
   if (cef.default_encoding.length > 0)
     web.default_encoding = CefString(&cef.default_encoding);
-  else
-    web.default_encoding = "ISO-8859-1";
 
-  web.javascript_enabled = !cef.javascript_disabled;
-  web.web_security_enabled = !cef.web_security_disabled;
-  web.javascript_can_open_windows_automatically =
-      !cef.javascript_open_windows_disallowed;
-  web.loads_images_automatically = !cef.image_load_disabled;
-  web.plugins_enabled = !cef.plugins_disabled;
-  web.dom_paste_enabled = !cef.dom_paste_disabled;
-  web.developer_extras_enabled = !cef.developer_tools_disabled;
-  web.inspector_settings.clear();
-  web.site_specific_quirks_enabled = !cef.site_specific_quirks_disabled;
-  web.shrinks_standalone_images_to_fit = cef.shrink_standalone_images_to_fit;
-  web.uses_universal_detector = cef.encoding_detector_enabled;
-  web.text_areas_are_resizable = !cef.text_area_resize_disabled;
-  web.java_enabled = !cef.java_disabled;
-  web.allow_scripts_to_close_windows = !cef.javascript_close_windows_disallowed;
-  web.uses_page_cache = !cef.page_cache_disabled;
-  web.remote_fonts_enabled = !cef.remote_fonts_disabled;
-  web.javascript_can_access_clipboard =
-      !cef.javascript_access_clipboard_disallowed;
-  web.xss_auditor_enabled = cef.xss_auditor_enabled;
-  web.local_storage_enabled = !cef.local_storage_disabled;
-  web.databases_enabled = !cef.databases_disabled;
-  web.application_cache_enabled = !cef.application_cache_disabled;
-  web.tabs_to_links = !cef.tab_to_links_disabled;
-  web.caret_browsing_enabled = cef.caret_browsing_enabled;
-  web.hyperlink_auditing_enabled = !cef.hyperlink_auditing_disabled;
-
-  web.user_style_sheet_enabled = cef.user_style_sheet_enabled;
-
-  if (cef.user_style_sheet_location.length > 0) {
+  if (cef.javascript_disabled)
+    web.javascript_enabled = false;
+  if (cef.web_security_disabled)
+    web.web_security_enabled = false;
+  if (cef.javascript_open_windows_disallowed)
+    web.javascript_can_open_windows_automatically = false;
+  if (cef.image_load_disabled)
+    web.loads_images_automatically = false;
+  if (cef.plugins_disabled)
+    web.plugins_enabled = false;
+  if (cef.dom_paste_disabled)
+    web.dom_paste_enabled = false;
+  if (cef.developer_tools_disabled)
+    web.developer_extras_enabled = false;
+  if (cef.site_specific_quirks_disabled)
+    web.site_specific_quirks_enabled = false;
+  if (cef.shrink_standalone_images_to_fit)
+    web.shrinks_standalone_images_to_fit = true;
+  if (cef.encoding_detector_enabled)
+    web.uses_universal_detector = true;
+  if (cef.text_area_resize_disabled)
+    web.text_areas_are_resizable = false;
+  if (cef.java_disabled)
+     web.java_enabled = false;
+  if (cef.javascript_close_windows_disallowed)
+    web.allow_scripts_to_close_windows = false;
+  if (cef.page_cache_disabled)
+    web.uses_page_cache = false;
+  if (cef.remote_fonts_disabled)
+    web.remote_fonts_enabled = true;
+  if (cef.javascript_access_clipboard_disallowed)
+    web.javascript_can_access_clipboard = false;
+  if (cef.xss_auditor_enabled)
+    web.xss_auditor_enabled = true;
+  if (cef.local_storage_disabled)
+    web.local_storage_enabled = false;
+  if (cef.databases_disabled)
+    web.databases_enabled = false;
+  if (cef.application_cache_disabled)
+    web.application_cache_enabled = false;
+  if (cef.tab_to_links_disabled)
+    web.tabs_to_links = false;
+  if (cef.caret_browsing_enabled)
+    web.caret_browsing_enabled = true;
+  if (cef.hyperlink_auditing_disabled)
+    web.hyperlink_auditing_enabled = true;
+  if (cef.user_style_sheet_enabled &&
+      cef.user_style_sheet_location.length > 0) {
+    web.user_style_sheet_enabled = true;
     web.user_style_sheet_location =
         GURL(std::string(CefString(&cef.user_style_sheet_location)));
   }
+  if (cef.author_and_user_styles_disabled)
+    web.author_and_user_styles_enabled = false;
+  if (cef.universal_access_from_file_urls_allowed)
+    web.allow_universal_access_from_file_urls = true;
+  if (cef.file_access_from_file_urls_allowed)
+    web.allow_file_access_from_file_urls = true;
 
-  web.author_and_user_styles_enabled = !cef.author_and_user_styles_disabled;
-  web.allow_universal_access_from_file_urls =
-      cef.universal_access_from_file_urls_allowed;
-  web.allow_file_access_from_file_urls = cef.file_access_from_file_urls_allowed;
-  web.experimental_webgl_enabled =
-      content::GpuProcessHost::gpu_enabled() && !cef.webgl_disabled;
-  web.gl_multisampling_enabled = web.experimental_webgl_enabled;
-  web.show_composited_layer_borders = false;
-  web.accelerated_compositing_enabled =
-      content::GpuProcessHost::gpu_enabled() && !cef.accelerated_compositing_disabled;
-  web.accelerated_layers_enabled = !cef.accelerated_layers_disabled;
-  web.accelerated_video_enabled = !cef.accelerated_video_disabled;
-  web.accelerated_2d_canvas_enabled =
-      content::GpuProcessHost::gpu_enabled() && !cef.accelerated_2d_canvas_disabled;
-  web.accelerated_painting_enabled =
-      content::GpuProcessHost::gpu_enabled() && cef.accelerated_painting_enabled;
-  web.accelerated_filters_enabled =
-      content::GpuProcessHost::gpu_enabled() && cef.accelerated_filters_enabled;
-  web.accelerated_plugins_enabled = !cef.accelerated_plugins_disabled;
-  web.memory_info_enabled = false;
-  web.fullscreen_enabled = cef.fullscreen_enabled;
-
-  // TODO(cef): The GPU black list will need to be initialized. See
-  // InitializeGpuDataManager() in chrome/browser/chrome_browser_main.cc.
-  {  // Certain GPU features might have been blacklisted.
-    content::GpuDataManager* gpu_data_manager =
-        content::GpuDataManager::GetInstance();
-    DCHECK(gpu_data_manager);
-    content::GpuFeatureType blacklist_flags =
-        gpu_data_manager->GetBlacklistedFeatures();
-    if (blacklist_flags & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)
-      web.accelerated_compositing_enabled = false;
-    if (blacklist_flags & content::GPU_FEATURE_TYPE_WEBGL)
-      web.experimental_webgl_enabled = false;
-    if (blacklist_flags & content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)
-      web.accelerated_2d_canvas_enabled = false;
-    if (blacklist_flags & content::GPU_FEATURE_TYPE_MULTISAMPLING)
-      web.gl_multisampling_enabled = false;
-
-    // Accelerated video is slower than regular when using a software 3d
-    // rasterizer.
-    if (gpu_data_manager->ShouldUseSoftwareRendering())
-      web.accelerated_video_enabled = false;
+  // Never explicitly enable GPU-related functions in this method because the
+  // GPU blacklist is not being checked here.
+  if (cef.webgl_disabled) {
+    web.experimental_webgl_enabled = false;
+    web.gl_multisampling_enabled = false;
   }
+  if (cef.accelerated_compositing_disabled)
+    web.accelerated_compositing_enabled = false;
+  if (cef.accelerated_layers_disabled) {
+    web.accelerated_compositing_for_3d_transforms_enabled = false;
+    web.accelerated_compositing_for_animation_enabled = false;
+  }
+  if (cef.accelerated_video_disabled)
+    web.accelerated_compositing_for_video_enabled = false;
+  if (cef.accelerated_2d_canvas_disabled)
+    web.accelerated_2d_canvas_enabled = false;
+  if (cef.accelerated_plugins_disabled)
+    web.accelerated_compositing_for_plugins_enabled = false;
 }

libcef/browser/resource_request_job.cc

@@ -18,11 +18,31 @@
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
+#include "net/url_request/http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 using net::URLRequestStatus;
 
+namespace {
+
+bool SetHeaderIfMissing(CefRequest::HeaderMap& headerMap,
+                        const std::string& name,
+                        const std::string& value) {
+  if (value.empty())
+    return false;
+                              
+  CefRequest::HeaderMap::const_iterator it = headerMap.find(name);
+  if (it == headerMap.end()) {
+    headerMap.insert(std::make_pair(name, value));
+    return true;
+  }
+
+  return false;
+}
+
+}  // namespace
+
 // Client callback for asynchronous response continuation.
 class CefResourceRequestJobCallback : public CefCallback {
  public:
@@ -153,32 +173,26 @@ void CefResourceRequestJob::Start() {
     cef_request_->GetHeaderMap(headerMap);
     bool changed = false;
 
-    if (!context->accept_language().empty()) {
-      it = headerMap.find(net::HttpRequestHeaders::kAcceptLanguage);
-      if (it == headerMap.end()) {
-        headerMap.insert(
-            std::make_pair(net::HttpRequestHeaders::kAcceptLanguage,
-                           context->accept_language()));
+    const net::HttpUserAgentSettings* ua_settings =
+        context->http_user_agent_settings();
+    if (ua_settings) {
+      if (SetHeaderIfMissing(headerMap,
+                             net::HttpRequestHeaders::kAcceptLanguage,
+                             ua_settings->GetAcceptLanguage())) {
+        changed = true;
       }
-      changed = true;
-    }
 
-    if (!context->accept_charset().empty()) {
-      it = headerMap.find(net::HttpRequestHeaders::kAcceptCharset);
-      if (it == headerMap.end()) {
-        headerMap.insert(
-            std::make_pair(net::HttpRequestHeaders::kAcceptCharset,
-                           context->accept_charset()));
+      if (SetHeaderIfMissing(headerMap,
+                             net::HttpRequestHeaders::kAcceptCharset,
+                             ua_settings->GetAcceptCharset())) {
+        changed = true;
       }
-      changed = true;
-    }
 
-    it = headerMap.find(net::HttpRequestHeaders::kUserAgent);
-    if (it == headerMap.end()) {
-      headerMap.insert(
-          std::make_pair(net::HttpRequestHeaders::kUserAgent,
-                         context->GetUserAgent(request_->url())));
-      changed = true;
+      if (SetHeaderIfMissing(headerMap,
+                             net::HttpRequestHeaders::kUserAgent,
+                             ua_settings->GetUserAgent(request_->url()))) {
+        changed = true;
+      }
     }
 
     if (changed)

libcef/browser/url_request_context_getter.cc

@@ -20,6 +20,7 @@
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_split.h"
+#include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
@@ -38,6 +39,7 @@
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_service.h"
+#include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_storage.h"
@@ -161,8 +163,9 @@ net::URLRequestContext* CefURLRequestContextGetter::GetURLRequestContext() {
     storage_->set_server_bound_cert_service(new net::ServerBoundCertService(
         new net::DefaultServerBoundCertStore(NULL),
         base::WorkerPool::GetTaskRunner(true)));
-    url_request_context_->set_accept_language("en-us,en");
-    url_request_context_->set_accept_charset("iso-8859-1,*,utf-8");
+    storage_->set_http_user_agent_settings(
+        new net::StaticHttpUserAgentSettings(
+            "en-us,en", "iso-8859-1,*,utf-8", EmptyString()));
 
     storage_->set_host_resolver(net::HostResolver::CreateDefaultResolver(NULL));
     storage_->set_cert_verifier(net::CertVerifier::CreateDefault());

libcef/browser/url_request_context_proxy.cc

@@ -129,10 +129,6 @@ CefURLRequestContextProxy::CefURLRequestContextProxy(
 CefURLRequestContextProxy::~CefURLRequestContextProxy() {
 }
 
-const std::string& CefURLRequestContextProxy::GetUserAgent(const GURL& url) const {
-  return parent_->GetURLRequestContext()->GetUserAgent(url);
-}
-
 void CefURLRequestContextProxy::Initialize(CefBrowserHostImpl* browser) {
   CEF_REQUIRE_IOT();
 
@@ -157,7 +153,7 @@ void CefURLRequestContextProxy::Initialize(CefBrowserHostImpl* browser) {
   set_network_delegate(context->network_delegate());
   set_http_server_properties(context->http_server_properties());
   set_transport_security_state(context->transport_security_state());
-  set_accept_charset(context->accept_charset());
-  set_accept_language(context->accept_language());
+  set_http_user_agent_settings(const_cast<net::HttpUserAgentSettings*>(
+      context->http_user_agent_settings()));
   set_job_factory(context->job_factory());
 }

libcef/browser/url_request_context_proxy.h

@@ -21,8 +21,6 @@ class CefURLRequestContextProxy : public net::URLRequestContext {
   explicit CefURLRequestContextProxy(net::URLRequestContextGetter* parent);
   virtual ~CefURLRequestContextProxy();
 
-  virtual const std::string& GetUserAgent(const GURL& url) const OVERRIDE;
-
   void Initialize(CefBrowserHostImpl* browser);
 
   // We may try to delete this proxy multiple times if URLRequests are still

libcef/common/cef_messages.cc

@@ -73,7 +73,7 @@ void ParamTraits<scoped_refptr<net::UploadData> >::Write(Message* m,
                                                          const param_type& p) {
   WriteParam(m, p.get() != NULL);
   if (p) {
-    WriteParam(m, *p->elements());
+    WriteParam(m, p->elements());
     WriteParam(m, p->identifier());
     WriteParam(m, p->is_chunked());
     WriteParam(m, p->last_chunk_appended());
@@ -88,7 +88,7 @@ bool ParamTraits<scoped_refptr<net::UploadData> >::Read(const Message* m,
     return false;
   if (!has_object)
     return true;
-  std::vector<net::UploadElement> elements;
+  ScopedVector<net::UploadElement> elements;
   if (!ReadParam(m, iter, &elements))
     return false;
   int64 identifier;

libcef/common/request_impl.cc

@@ -407,11 +407,11 @@ void CefPostDataImpl::Set(const net::UploadData& data) {
 
   CefRefPtr<CefPostDataElement> postelem;
 
-  const std::vector<net::UploadElement>* elements = data.elements();
-  std::vector<net::UploadElement>::const_iterator it = elements->begin();
-  for (; it != elements->end(); ++it) {
+  const ScopedVector<net::UploadElement>& elements = data.elements();
+  ScopedVector<net::UploadElement>::const_iterator it = elements.begin();
+  for (; it != elements.end(); ++it) {
     postelem = CefPostDataElement::Create();
-    static_cast<CefPostDataElementImpl*>(postelem.get())->Set(*it);
+    static_cast<CefPostDataElementImpl*>(postelem.get())->Set(**it);
     AddElement(postelem);
   }
 }
@@ -419,14 +419,14 @@ void CefPostDataImpl::Set(const net::UploadData& data) {
 void CefPostDataImpl::Get(net::UploadData& data) {
   AutoLock lock_scope(this);
 
-  net::UploadElement element;
-  std::vector<net::UploadElement> data_elements;
+  ScopedVector<net::UploadElement> data_elements;
   ElementVector::const_iterator it = elements_.begin();
   for (; it != elements_.end(); ++it) {
-    static_cast<CefPostDataElementImpl*>(it->get())->Get(element);
+    net::UploadElement* element = new net::UploadElement();
+    static_cast<CefPostDataElementImpl*>(it->get())->Get(*element);
     data_elements.push_back(element);
   }
-  data.SetElements(data_elements);
+  data.swap_elements(&data_elements);
 }
 
 void CefPostDataImpl::Set(const WebKit::WebHTTPBody& data) {

libcef/renderer/browser_impl.cc

@@ -311,12 +311,12 @@ void CefBrowserImpl::LoadRequest(const CefMsg_LoadRequest_Params& params) {
     WebKit::WebHTTPBody body;
     body.initialize();
 
-    const std::vector<net::UploadElement>* elements =
+    const ScopedVector<net::UploadElement>& elements =
         params.upload_data->elements();
-    std::vector<net::UploadElement>::const_iterator it =
-        elements->begin();
-    for (; it != elements->end(); ++it) {
-      const net::UploadElement& element = *it;
+    ScopedVector<net::UploadElement>::const_iterator it =
+        elements.begin();
+    for (; it != elements.end(); ++it) {
+      const net::UploadElement& element = **it;
       if (element.type() == net::UploadElement::TYPE_BYTES) {
         WebKit::WebData data;
         data.assign(element.bytes(), element.bytes_length());

patch/patch.cfg

@@ -26,11 +26,6 @@ patches = [
     'name': 'zlib',
     'path': '../third_party/zlib/',
   },
-  {
-    # https://codereview.chromium.org/11293157/
-    'name': 'content_navigation',
-    'path': '../content/',
-  },
   {
     # http://code.google.com/p/chromiumembedded/issues/detail?id=364
     'name': 'spi_webcore_364',

patch/patches/content_navigation.patch

@@ -1,66 +0,0 @@
-Index: public/renderer/content_renderer_client.cc
-===================================================================
---- public/renderer/content_renderer_client.cc	(revision 165669)
-+++ public/renderer/content_renderer_client.cc	(working copy)
-@@ -56,6 +56,15 @@
-   return false;
- }
- 
-+bool ContentRendererClient::HandleNavigation(
-+    WebKit::WebFrame* frame,
-+    const WebKit::WebURLRequest& request,
-+    WebKit::WebNavigationType type,
-+    WebKit::WebNavigationPolicy default_policy,
-+    bool is_redirect) {
-+  return false;
-+}
-+
- bool ContentRendererClient::ShouldFork(WebKit::WebFrame* frame,
-                                        const GURL& url,
-                                        bool is_initial_navigation,
-Index: public/renderer/content_renderer_client.h
-===================================================================
---- public/renderer/content_renderer_client.h	(revision 165669)
-+++ public/renderer/content_renderer_client.h	(working copy)
-@@ -12,6 +12,8 @@
- #include "ipc/ipc_message.h"
- #include "content/public/common/content_client.h"
- #include "content/public/common/page_transition_types.h"
-+#include "third_party/WebKit/Source/WebKit/chromium/public/WebNavigationPolicy.h"
-+#include "third_party/WebKit/Source/WebKit/chromium/public/WebNavigationType.h"
- #include "third_party/WebKit/Source/WebKit/chromium/public/WebPageVisibilityState.h"
- #include "v8/include/v8.h"
- 
-@@ -130,6 +132,14 @@
-   // Returns true if the given url can create popup windows.
-   virtual bool AllowPopup(const GURL& creator);
- 
-+  // Returns true if the navigation was handled by the embedder and should be
-+  // ignored by WebKit. This method is used by CEF.
-+  virtual bool HandleNavigation(WebKit::WebFrame* frame,
-+                                const WebKit::WebURLRequest& request,
-+                                WebKit::WebNavigationType type,
-+                                WebKit::WebNavigationPolicy default_policy,
-+                                bool is_redirect);
-+
-   // Returns true if we should fork a new process for the given navigation.
-   virtual bool ShouldFork(WebKit::WebFrame* frame,
-                           const GURL& url,
-Index: renderer/render_view_impl.cc
-===================================================================
---- renderer/render_view_impl.cc	(revision 165669)
-+++ renderer/render_view_impl.cc	(working copy)
-@@ -2674,6 +2674,13 @@
- WebNavigationPolicy RenderViewImpl::decidePolicyForNavigation(
-     WebFrame* frame, const WebURLRequest& request, WebNavigationType type,
-     const WebNode&, WebNavigationPolicy default_policy, bool is_redirect) {
-+  if (request.url() != GURL(kSwappedOutURL) &&
-+      GetContentClient()->renderer()->HandleNavigation(frame, request, type,
-+                                                       default_policy,
-+                                                       is_redirect)) {
-+    return WebKit::WebNavigationPolicyIgnore;
-+  }
-+
-   Referrer referrer(
-       GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
-       GetReferrerPolicyFromRequest(frame, request));

tests/cefclient/cefclient.cpp

@@ -181,16 +181,10 @@ void AppGetBrowserSettings(CefBrowserSettings& settings) {
       g_command_line->HasSwitch(cefclient::kAcceleratedVideoDisabled);
   settings.accelerated_2d_canvas_disabled =
       g_command_line->HasSwitch(cefclient::kAcceledated2dCanvasDisabled);
-  settings.accelerated_painting_enabled =
-      g_command_line->HasSwitch(cefclient::kAcceleratedPaintingEnabled);
-  settings.accelerated_filters_enabled =
-      g_command_line->HasSwitch(cefclient::kAcceleratedFiltersEnabled);
   settings.accelerated_plugins_disabled =
       g_command_line->HasSwitch(cefclient::kAcceleratedPluginsDisabled);
   settings.developer_tools_disabled =
       g_command_line->HasSwitch(cefclient::kDeveloperToolsDisabled);
-  settings.fullscreen_enabled =
-      g_command_line->HasSwitch(cefclient::kFullscreenEnabled);
 }
 
 void RunGetSourceTest(CefRefPtr<CefBrowser> browser) {

tests/cefclient/client_switches.cpp

@@ -55,11 +55,8 @@ const char kAcceleratedCompositingDisabled[] =
 const char kAcceleratedLayersDisabled[] = "accelerated-layers-disabled";
 const char kAcceleratedVideoDisabled[] = "accelerated-video-disabled";
 const char kAcceledated2dCanvasDisabled[] = "accelerated-2d-canvas-disabled";
-const char kAcceleratedPaintingEnabled[] = "accelerated-painting-enabled";
-const char kAcceleratedFiltersEnabled[] = "accelerated-filters-enabled";
 const char kAcceleratedPluginsDisabled[] = "accelerated-plugins-disabled";
 const char kDeveloperToolsDisabled[] = "developer-tools-disabled";
-const char kFullscreenEnabled[] = "fullscreen-enabled";
 
 // Other attributes.
 const char kProxyType[] = "proxy-type";

tests/cefclient/client_switches.h

@@ -51,11 +51,8 @@ extern const char kAcceleratedCompositingDisabled[];
 extern const char kAcceleratedLayersDisabled[];
 extern const char kAcceleratedVideoDisabled[];
 extern const char kAcceledated2dCanvasDisabled[];
-extern const char kAcceleratedPaintingEnabled[];
-extern const char kAcceleratedFiltersEnabled[];
 extern const char kAcceleratedPluginsDisabled[];
 extern const char kDeveloperToolsDisabled[];
-extern const char kFullscreenEnabled[];
 
 // Other attributes.
 extern const char kProxyType[];