Remove dependency on GURL from content/common/gpu

content/common/gpu/gpu_command_buffer_stub.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 "content/common/gpu/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 89 matching lines @@
   scoped_ptr<GpuMemoryTrackingGroup> tracking_group_;
   const uint64_t client_tracing_id_;
   const int client_id_;
   const uint64_t share_group_tracing_guid_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferMemoryTracker);
 };
 
 // FastSetActiveURL will shortcut the expensive call to SetActiveURL when the
 // url_hash matches.
-void FastSetActiveURL(const GURL& url, size_t url_hash) {
+void FastSetActiveURL(const std::string& url, size_t url_hash) {
   // Leave the previously set URL in the empty case -- empty URLs are given by
   // BlinkPlatformImpl::createOffscreenGraphicsContext3D. Hopefully the
   // onscreen context URL was set previously and will show up even when a crash
   // occurs during offscreen command processing.
-  if (url.is_empty())
+  if (url.empty())
     return;
   static size_t g_last_url_hash = 0;
   if (url_hash != g_last_url_hash) {
     g_last_url_hash = url_hash;
     GetContentClient()->SetActiveURL(url);
   }
 }
 
 // The first time polling a fence, delay some extra time to allow other
 // stubs to process some work, or else the timing of the fences could
@@ skipping 60 matching lines @@
     gpu::gles2::SubscriptionRefSet* subscription_ref_set,
     gpu::ValueStateMap* pending_valuebuffer_state,
     const gfx::Size& size,
     const gpu::gles2::DisallowedFeatures& disallowed_features,
     const std::vector<int32_t>& attribs,
     gfx::GpuPreference gpu_preference,
     int32_t stream_id,
     int32_t route_id,
     bool offscreen,
     GpuWatchdog* watchdog,
-    const GURL& active_url)
+    const std::string& active_url)
     : channel_(channel),
       sync_point_manager_(sync_point_manager),
       task_runner_(task_runner),
       initialized_(false),
       handle_(handle),
       initial_size_(size),
       disallowed_features_(disallowed_features),
       requested_attribs_(attribs),
       gpu_preference_(gpu_preference),
       use_virtualized_gl_context_(false),
       command_buffer_id_(GetCommandBufferID(channel->client_id(), route_id)),
       stream_id_(stream_id),
       route_id_(route_id),
       offscreen_(offscreen),
       last_flush_count_(0),
       surface_format_(gfx::GLSurface::SURFACE_DEFAULT),
       watchdog_(watchdog),
       waiting_for_sync_point_(false),
       previous_processed_num_(0),
       preemption_flag_(preempt_by_flag),
       active_url_(active_url) {
-  active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
+  active_url_hash_ = base::Hash(active_url);
   FastSetActiveURL(active_url_, active_url_hash_);
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
     context_group_ = share_group->context_group_;
     DCHECK(context_group_->bind_generates_resource() ==
            attrib_parser.bind_generates_resource);
   } else {
@@ skipping 234 matching lines @@
     Send(wait_for_token_->reply.release());
     wait_for_token_.reset();
   }
   if (wait_for_get_offset_) {
     Send(wait_for_get_offset_->reply.release());
     wait_for_get_offset_.reset();
   }
 
   if (initialized_) {
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
-    if (handle_.is_null() && !active_url_.is_empty()) {
+    if (handle_.is_null() && !active_url_.empty()) {
       gpu_channel_manager->Send(
           new GpuHostMsg_DidDestroyOffscreenContext(active_url_));
     }
   }
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
@@ skipping 182 matching lines @@
   }
   command_buffer_->SetSharedStateBuffer(gpu::MakeBackingFromSharedMemory(
       std::move(shared_state_shm), kSharedStateSize));
 
   gpu::Capabilities capabilities = decoder_->GetCapabilities();
 
   GpuCommandBufferMsg_Initialize::WriteReplyParams(
       reply_message, true, capabilities);
   Send(reply_message);
 
-  if (handle_.is_null() && !active_url_.is_empty()) {
+  if (handle_.is_null() && !active_url_.empty()) {
     manager->Send(new GpuHostMsg_DidCreateOffscreenContext(
         active_url_));
   }
 
   initialized_ = true;
 }
 
 void GpuCommandBufferStub::OnCreateStreamTexture(uint32_t texture_id,
                                                  int32_t stream_id,
                                                  bool* succeeded) {
@@ skipping 491 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content