Update to Chromium revision 167921.

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

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());