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"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
+#include "content/common/gpu/gpu_channel_manager_delegate.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_memory_tracking.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_watchdog.h"
 #include "content/common/gpu/image_transport_surface.h"
 #include "content/common/gpu/media/gpu_video_decode_accelerator.h"
 #include "content/common/gpu/media/gpu_video_encode_accelerator.h"
 #include "content/public/common/content_client.h"

[Fady Samuel, 2016/02/19 18:38:36]

You can remove this include now, right?

[Mark Dittmer, 2016/02/20 00:55:20]

Done.

 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
@@ skipping 59 matching lines @@
  private:
   ~GpuCommandBufferMemoryTracker() override {}
   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) {
-  // 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())
-    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
 // allow a pattern of alternating fast and slow frames to occur.
 const int64_t kHandleMoreWorkPeriodMs = 2;
 const int64_t kHandleMoreWorkPeriodBusyMs = 1;
 
 // Prevents idle work from being starved.
 const int64_t kMaxTimeSinceIdleMs = 10;
 
 class DevToolsChannelData : public base::trace_event::ConvertableToTraceFormat {
@@ skipping 53 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 180 matching lines @@
 
   if (command_buffer_)
     command_buffer_->DestroyTransferBuffer(id);
 }
 
 void GpuCommandBufferStub::OnCommandProcessed() {
   if (watchdog_)
     watchdog_->CheckArmed();
 }
 
+void GpuCommandBufferStub::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.empty())
+    return;
+  static size_t g_last_url_hash = 0;
+  if (url_hash != g_last_url_hash) {
+    g_last_url_hash = url_hash;
+    // Plumb request through to a component that knows about the current active
+    // URLs.
+    channel_->gpu_channel_manager()->delegate()->SetActiveURL(url);
+  }
+}
+
 void GpuCommandBufferStub::ReportState() { command_buffer_->UpdateState(); }
 
 void GpuCommandBufferStub::PutChanged() {
   FastSetActiveURL(active_url_, active_url_hash_);
   scheduler_->PutChanged();
 }
 
 void GpuCommandBufferStub::OnCreateVideoDecoder(
     const media::VideoDecodeAccelerator::Config& config,
     int32_t decoder_route_id,
@@ skipping 291 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content