blink: Rename modules/ method to prefix with get when they collide.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 2427 matching lines @@
                   ->renderer()
                   ->CreateBrowserPluginDelegate(this, kBrowserPluginMimeType,
                                                 GURL(params.url))
                   ->GetWeakPtr());
   }
 
 #if defined(ENABLE_PLUGINS)
   WebPluginInfo info;
   std::string mime_type;
   bool found = false;
-  WebString top_origin = frame->top()->securityOrigin().toString();
+  WebString top_origin = frame->top()->getSecurityOrigin().toString();
   Send(new FrameHostMsg_GetPluginInfo(routing_id_, params.url,
                                       blink::WebStringToGURL(top_origin),
                                       params.mimeType.utf8(), &found, &info,
                                       &mime_type));
   if (!found)
     return NULL;
 
   WebPluginParams params_to_use = params;
   params_to_use.mimeType = WebString::fromUTF8(mime_type);
   return CreatePlugin(frame, info, params_to_use, nullptr /* throttler */);
@@ skipping 14 matching lines @@
   if (!contains_media_player_) {
     render_view_->RegisterVideoHoleFrame(this);
     contains_media_player_ = true;
   }
 #endif  // defined(VIDEO_HOLE)
 
   blink::WebMediaStream web_stream(
       blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url));
   if (!web_stream.isNull())
     return CreateWebMediaPlayerForMediaStream(client, sink_id,
-                                              frame_->securityOrigin());
+                                              frame_->getSecurityOrigin());
 
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
 
   scoped_refptr<media::RestartableAudioRendererSink> audio_renderer_sink =
       AudioDeviceFactory::NewRestartableAudioRendererSink(
           AudioDeviceFactory::kSourceMediaElement, routing_id_, 0,
-          sink_id.utf8(), frame_->securityOrigin());
+          sink_id.utf8(), frame_->getSecurityOrigin());
   media::WebMediaPlayerParams::Context3DCB context_3d_cb =
       base::Bind(&GetSharedMainThreadContext3D);
 
   scoped_refptr<media::MediaLog> media_log(new RenderMediaLog());
 #if defined(OS_ANDROID)
   if (!media_surface_manager_)
     media_surface_manager_ = new RendererSurfaceViewManager(this);
 #endif
   media::WebMediaPlayerParams params(
       base::Bind(&ContentRendererClient::DeferMediaLoad,
@@ skipping 1210 matching lines @@
       // This is broken and should be fixed to propagate the first party.
       WebFrame* top = frame->top();
       if (top->isWebLocalFrame()) {
         request.setFirstPartyForCookies(
             frame->top()->document().firstPartyForCookies());
       }
     }
 
     // If we need to set the first party, then we need to set the request's
     // initiator as well; it will not be updated during redirects.
-    request.setRequestorOrigin(frame->document().securityOrigin());
+    request.setRequestorOrigin(frame->document().getSecurityOrigin());
   }
 
   WebDataSource* provisional_data_source = frame->provisionalDataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : frame->dataSource();
 
   DocumentState* document_state = DocumentState::FromDataSource(data_source);
   DCHECK(document_state);
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
@@ skipping 106 matching lines @@
   WebFrame* parent = frame->parent();
   int parent_routing_id = parent ? GetRoutingIdForFrameOrProxy(parent) : -1;
 
   RequestExtraData* extra_data = new RequestExtraData();
   extra_data->set_visibility_state(render_view_->visibilityState());
   extra_data->set_custom_user_agent(custom_user_agent);
   extra_data->set_requested_with(requested_with);
   extra_data->set_render_frame_id(routing_id_);
   extra_data->set_is_main_frame(!parent);
   extra_data->set_frame_origin(
-      blink::WebStringToGURL(frame->document().securityOrigin().toString()));
+      blink::WebStringToGURL(frame->document().getSecurityOrigin().toString()));
   extra_data->set_parent_is_main_frame(parent && !parent->parent());
   extra_data->set_parent_render_frame_id(parent_routing_id);
   extra_data->set_allow_download(
       navigation_state->common_params().allow_download);
   extra_data->set_transition_type(transition_type);
   extra_data->set_should_replace_current_entry(should_replace_current_entry);
   extra_data->set_transferred_request_child_id(
       navigation_state->start_params().transferred_request_child_id);
   extra_data->set_transferred_request_request_id(
       navigation_state->start_params().transferred_request_request_id);
@@ skipping 206 matching lines @@
     int active_match_ordinal,
     const blink::WebRect& selection_rect) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, -1, selection_rect,
                                    active_match_ordinal, false));
 }
 
 void RenderFrameImpl::requestStorageQuota(
     blink::WebStorageQuotaType type,
     unsigned long long requested_size,
     blink::WebStorageQuotaCallbacks callbacks) {
-  WebSecurityOrigin origin = frame_->document().securityOrigin();
+  WebSecurityOrigin origin = frame_->document().getSecurityOrigin();
   if (origin.isUnique()) {
     // Unique origins cannot store persistent state.
     callbacks.didFail(blink::WebStorageQuotaErrorAbort);
     return;
   }
   ChildThreadImpl::current()->quota_dispatcher()->RequestStorageQuota(
       render_view_->GetRoutingID(),
       blink::WebStringToGURL(origin.toString()),
       static_cast<storage::StorageType>(type),
       requested_size,
@@ skipping 134 matching lines @@
   return WebString();
 }
 
 bool RenderFrameImpl::allowWebGL(bool default_value) {
   if (!default_value)
     return false;
 
   bool blocked = true;
   Send(new FrameHostMsg_Are3DAPIsBlocked(
       routing_id_,
-      blink::WebStringToGURL(frame_->top()->securityOrigin().toString()),
-      THREE_D_API_TYPE_WEBGL,
-      &blocked));
+      blink::WebStringToGURL(frame_->top()->getSecurityOrigin().toString()),
+      THREE_D_API_TYPE_WEBGL, &blocked));
   return !blocked;
 }
 
 void RenderFrameImpl::didLoseWebGLContext(int arb_robustness_status_code) {
   Send(new FrameHostMsg_DidLose3DContext(
-      blink::WebStringToGURL(frame_->top()->securityOrigin().toString()),
-      THREE_D_API_TYPE_WEBGL,
-      arb_robustness_status_code));
+      blink::WebStringToGURL(frame_->top()->getSecurityOrigin().toString()),
+      THREE_D_API_TYPE_WEBGL, arb_robustness_status_code));
 }
 
 blink::WebScreenOrientationClient*
     RenderFrameImpl::webScreenOrientationClient() {
   if (!screen_orientation_dispatcher_)
     screen_orientation_dispatcher_ = new ScreenOrientationDispatcher(this);
   return screen_orientation_dispatcher_;
 }
 
 bool RenderFrameImpl::isControlledByServiceWorker(WebDataSource& data_source) {
@@ skipping 216 matching lines @@
   if (extra_data)
     params.was_fetched_via_proxy = extra_data->was_fetched_via_proxy();
   params.was_within_same_page = navigation_state->WasWithinSamePage();
   params.security_info = response.securityInfo();
 
   // Set the origin of the frame.  This will be replicated to the corresponding
   // RenderFrameProxies in other processes.
   // TODO(alexmos): Origins for URLs with non-standard schemes are excluded due
   // to https://crbug.com/439608 and will be replicated as unique origins.
   if (!is_swapped_out_) {
-    std::string scheme = frame->document().securityOrigin().protocol().utf8();
+    std::string scheme =
+        frame->document().getSecurityOrigin().protocol().utf8();
     if (url::IsStandard(scheme.c_str(),
                         url::Component(0, static_cast<int>(scheme.length())))) {
-      params.origin = frame->document().securityOrigin();
+      params.origin = frame->document().getSecurityOrigin();
     }
   }
 
   params.should_enforce_strict_mixed_content_checking =
       frame->shouldEnforceStrictMixedContentChecking();
 
   // Set the URL to be displayed in the browser UI to the user.
   params.url = GetLoadingUrl();
   DCHECK(!is_swapped_out_ || params.url == GURL(kSwappedOutURL));
 
@@ skipping 1642 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content