Convert WebSecurityOrigin -> GURL without re-parsing the url

chrome/renderer/content_settings_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/content_settings_observer.h"
 
 #include "chrome/common/render_messages.h"
 #include "chrome/common/ssl_insecure_content.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebContentSettingCallbacks.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
+#include "url/origin.h"
 #include "url/url_constants.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/renderer/dispatcher.h"
 #include "extensions/renderer/renderer_extension_registry.h"
 #endif
 
 using blink::WebContentSettingCallbacks;
 using blink::WebDataSource;
 using blink::WebDocument;
 using blink::WebFrame;
 using blink::WebSecurityOrigin;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebView;
 using content::DocumentState;
 using content::NavigationState;
 
 namespace {
 
 GURL GetOriginOrURL(const WebFrame* frame) {
-  WebString top_origin = frame->top()->getSecurityOrigin().toString();
+  url::Origin top_origin = url::Origin(frame->top()->getSecurityOrigin());
   // The |top_origin| is unique ("null") e.g., for file:// URLs. Use the
   // document URL as the primary URL in those cases.
   // TODO(alexmos): This is broken for --site-per-process, since top() can be a
   // WebRemoteFrame which does not have a document(), and the WebRemoteFrame's
   // URL is not replicated.  See https://crbug.com/628759.
-  if (top_origin == "null" && frame->top()->isWebLocalFrame())
+  if (top_origin.unique() && frame->top()->isWebLocalFrame())
     return frame->top()->document().url();
-  return blink::WebStringToGURL(top_origin);
+  return top_origin.GetURL();
 }
 
 ContentSetting GetContentSettingFromRules(
     const ContentSettingsForOneType& rules,
     const WebFrame* frame,
     const GURL& secondary_url) {
   ContentSettingsForOneType::const_iterator it;
   // If there is only one rule, it's the default rule and we don't need to match
   // the patterns.
   if (rules.size() == 1) {
@@ skipping 136 matching lines @@
 bool ContentSettingsObserver::allowDatabase(const WebString& name,
                                             const WebString& display_name,
                                             unsigned estimated_size) {
   WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->getSecurityOrigin().isUnique() ||
       frame->top()->getSecurityOrigin().isUnique())
     return false;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowDatabase(
-      routing_id(),
-      blink::WebStringToGURL(frame->getSecurityOrigin().toString()),
-      blink::WebStringToGURL(frame->top()->getSecurityOrigin().toString()),
-      name, display_name, &result));
+      routing_id(), url::Origin(frame->getSecurityOrigin()).GetURL(),
+      url::Origin(frame->top()->getSecurityOrigin()).GetURL(), name,
+      display_name, &result));
   return result;
 }
 
 void ContentSettingsObserver::requestFileSystemAccessAsync(
     const WebContentSettingCallbacks& callbacks) {
   WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->getSecurityOrigin().isUnique() ||
       frame->top()->getSecurityOrigin().isUnique()) {
     WebContentSettingCallbacks permissionCallbacks(callbacks);
     permissionCallbacks.doDeny();
     return;
   }
   ++current_request_id_;
   std::pair<PermissionRequestMap::iterator, bool> insert_result =
       permission_requests_.insert(
           std::make_pair(current_request_id_, callbacks));
 
   // Verify there are no duplicate insertions.
   DCHECK(insert_result.second);
 
   Send(new ChromeViewHostMsg_RequestFileSystemAccessAsync(
       routing_id(), current_request_id_,
-      blink::WebStringToGURL(frame->getSecurityOrigin().toString()),
-      blink::WebStringToGURL(frame->top()->getSecurityOrigin().toString())));
+      url::Origin(frame->getSecurityOrigin()).GetURL(),
+      url::Origin(frame->top()->getSecurityOrigin()).GetURL()));
 }
 
 bool ContentSettingsObserver::allowImage(bool enabled_per_settings,
                                          const WebURL& image_url) {
   bool allow = enabled_per_settings;
   if (enabled_per_settings) {
     if (is_interstitial_page_)
       return true;
 
     if (IsWhitelistedForContentSettings())
@@ skipping 14 matching lines @@
 
 bool ContentSettingsObserver::allowIndexedDB(const WebString& name,
                                              const WebSecurityOrigin& origin) {
   WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->getSecurityOrigin().isUnique() ||
       frame->top()->getSecurityOrigin().isUnique())
     return false;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowIndexedDB(
-      routing_id(),
-      blink::WebStringToGURL(frame->getSecurityOrigin().toString()),
-      blink::WebStringToGURL(frame->top()->getSecurityOrigin().toString()),
-      name, &result));
+      routing_id(), url::Origin(frame->getSecurityOrigin()).GetURL(),
+      url::Origin(frame->top()->getSecurityOrigin()).GetURL(), name, &result));
   return result;
 }
 
 bool ContentSettingsObserver::allowPlugins(bool enabled_per_settings) {
   return enabled_per_settings;
 }
 
 bool ContentSettingsObserver::allowScript(bool enabled_per_settings) {
   if (!enabled_per_settings)
     return false;
   if (is_interstitial_page_)
     return true;
 
   WebFrame* frame = render_frame()->GetWebFrame();
   const auto it = cached_script_permissions_.find(frame);
   if (it != cached_script_permissions_.end())
     return it->second;
 
   // Evaluate the content setting rules before
   // |IsWhitelistedForContentSettings|; if there is only the default rule
   // allowing all scripts, it's quicker this way.
   bool allow = true;
   if (content_setting_rules_) {
     ContentSetting setting = GetContentSettingFromRules(
         content_setting_rules_->script_rules, frame,
-        blink::WebStringToGURL(
-            frame->document().getSecurityOrigin().toString()));
+        url::Origin(frame->document().getSecurityOrigin()).GetURL());
     allow = setting != CONTENT_SETTING_BLOCK;
   }
   allow = allow || IsWhitelistedForContentSettings();
 
   cached_script_permissions_[frame] = allow;
   return allow;
 }
 
 bool ContentSettingsObserver::allowScriptFromSource(
     bool enabled_per_settings,
@@ skipping 14 matching lines @@
   return allow || IsWhitelistedForContentSettings();
 }
 
 bool ContentSettingsObserver::allowStorage(bool local) {
   WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->getSecurityOrigin().isUnique() ||
       frame->top()->getSecurityOrigin().isUnique())
     return false;
 
   StoragePermissionsKey key(
-      blink::WebStringToGURL(frame->document().getSecurityOrigin().toString()),
-      local);
+      url::Origin(frame->document().getSecurityOrigin()).GetURL(), local);
   const auto permissions = cached_storage_permissions_.find(key);
   if (permissions != cached_storage_permissions_.end())
     return permissions->second;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowDOMStorage(
-      routing_id(),
-      blink::WebStringToGURL(frame->getSecurityOrigin().toString()),
-      blink::WebStringToGURL(frame->top()->getSecurityOrigin().toString()),
-      local, &result));
+      routing_id(), url::Origin(frame->getSecurityOrigin()).GetURL(),
+      url::Origin(frame->top()->getSecurityOrigin()).GetURL(), local, &result));
   cached_storage_permissions_[key] = result;
   return result;
 }
 
 bool ContentSettingsObserver::allowReadFromClipboard(bool default_value) {
   bool allowed = default_value;
 #if defined(ENABLE_EXTENSIONS)
   extensions::ScriptContext* current_context =
       extension_dispatcher_->script_context_set().GetCurrent();
   if (current_context) {
@@ skipping 42 matching lines @@
   return true;
 }
 
 bool ContentSettingsObserver::allowAutoplay(bool default_value) {
   if (!content_setting_rules_)
     return default_value;
 
   WebFrame* frame = render_frame()->GetWebFrame();
   return GetContentSettingFromRules(
              content_setting_rules_->autoplay_rules, frame,
-             blink::WebStringToGURL(
-                 frame->document().getSecurityOrigin().toString())) ==
+             url::Origin(frame->document().getSecurityOrigin()).GetURL()) ==
          CONTENT_SETTING_ALLOW;
 }
 
 void ContentSettingsObserver::passiveInsecureContentFound(
     const blink::WebURL& resource_url) {
   ReportInsecureContent(SslInsecureContentType::DISPLAY);
   FilteredReportInsecureContentDisplayed(GURL(resource_url));
 }
 
 void ContentSettingsObserver::didUseKeygen() {
   WebFrame* frame = render_frame()->GetWebFrame();
   Send(new ChromeViewHostMsg_DidUseKeygen(
-      routing_id(),
-      blink::WebStringToGURL(frame->getSecurityOrigin().toString())));
+      routing_id(), url::Origin(frame->getSecurityOrigin()).GetURL()));
 }
 
 void ContentSettingsObserver::didNotAllowPlugins() {
   DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS);
 }
 
 void ContentSettingsObserver::didNotAllowScript() {
   DidBlockContentType(CONTENT_SETTINGS_TYPE_JAVASCRIPT);
 }
 
@@ skipping 102 matching lines @@
 
   // If the scheme is file:, an empty file name indicates a directory listing,
   // which requires JavaScript to function properly.
   if (base::EqualsASCII(protocol, url::kFileScheme)) {
     return document_url.SchemeIs(url::kFileScheme) &&
            document_url.ExtractFileName().empty();
   }
 
   return false;
 }