Remove dependency on GURL from content/common/gpu

content/browser/gpu/gpu_process_host.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/browser/gpu/gpu_process_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 806 matching lines @@
 
   if (create_gpu_memory_buffer_requests_.empty())
     return;
 
   CreateGpuMemoryBufferCallback callback =
       create_gpu_memory_buffer_requests_.front();
   create_gpu_memory_buffer_requests_.pop();
   callback.Run(handle);
 }
 
-void GpuProcessHost::OnDidCreateOffscreenContext(const GURL& url) {
-  urls_with_live_offscreen_contexts_.insert(url);
+void GpuProcessHost::OnDidCreateOffscreenContext(const std::string& url) {
+  urls_with_live_offscreen_contexts_.insert(GURL(url));
 }
 
 void GpuProcessHost::OnDidLoseContext(bool offscreen,
                                       gpu::error::ContextLostReason reason,
-                                      const GURL& url) {
+                                      const std::string& url) {
+  const GURL gurl(url);
   // TODO(kbr): would be nice to see the "offscreen" flag too.
-  TRACE_EVENT2("gpu", "GpuProcessHost::OnDidLoseContext",
-               "reason", reason,
-               "url",
-               url.possibly_invalid_spec());
+  TRACE_EVENT2("gpu", "GpuProcessHost::OnDidLoseContext", "reason", reason,
+               "url", gurl.possibly_invalid_spec());
 
-  if (!offscreen || url.is_empty()) {
+  if (!offscreen || gurl.is_empty()) {
     // Assume that the loss of the compositor's or accelerated canvas'
     // context is a serious event and blame the loss on all live
     // offscreen contexts. This more robustly handles situations where
     // the GPU process may not actually detect the context loss in the
     // offscreen context.
     BlockLiveOffscreenContexts();
     return;
   }
 
   GpuDataManagerImpl::DomainGuilt guilt;
   switch (reason) {
     case gpu::error::kGuilty:
       guilt = GpuDataManagerImpl::DOMAIN_GUILT_KNOWN;
       break;
     case gpu::error::kUnknown:
       guilt = GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN;
       break;
     case gpu::error::kInnocent:
       return;
     default:
       NOTREACHED();
       return;
   }
 
-  GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(url, guilt);
+  GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(gurl, guilt);

[piman, 2016/02/18 18:29:28]

Oh, I hadn't realized we used the URL to extract the domain. We then need to
make sure the round-trip through a string is non-lossy. Is that the case that
GURL(url.spec()) is always identical to url?

[Mark Dittmer, 2016/02/18 21:10:25]

If GURL is stored on either end, and spec() is used for extract-to-send, then we
should be fine. spec() checks for an invalid URL, and then returns the
canonicalized URL. We could use possibly_invalid_spec(), but that seems less
safe to me.

 }
 
-void GpuProcessHost::OnDidDestroyOffscreenContext(const GURL& url) {
-  urls_with_live_offscreen_contexts_.erase(url);
+void GpuProcessHost::OnDidDestroyOffscreenContext(const std::string& url) {
+  urls_with_live_offscreen_contexts_.erase(GURL(url));
 }
 
 void GpuProcessHost::OnGpuMemoryUmaStatsReceived(
     const GPUMemoryUmaStats& stats) {
   TRACE_EVENT0("gpu", "GpuProcessHost::OnGpuMemoryUmaStatsReceived");
   uma_memory_stats_received_ = true;
   uma_memory_stats_ = stats;
 }
 
 #if defined(OS_MACOSX)
@@ skipping 267 matching lines @@
   TRACE_EVENT0("gpu", "GpuProcessHost::OnCacheShader");
   ClientIdToShaderCacheMap::iterator iter =
       client_id_to_shader_cache_.find(client_id);
   // If the cache doesn't exist then this is an off the record profile.
   if (iter == client_id_to_shader_cache_.end())
     return;
   iter->second->Cache(GetShaderPrefixKey() + ":" + key, shader);
 }
 
 }  // namespace content