make ProxyService::CreateSystemProxyConfigService return scoped_ptrs NOT FOR REVIEW

content/shell/browser/shell_url_request_context_getter.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/shell/browser/shell_url_request_context_getter.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 76 matching lines @@
 
 ShellURLRequestContextGetter::~ShellURLRequestContextGetter() {
 }
 
 net::NetworkDelegate* ShellURLRequestContextGetter::CreateNetworkDelegate() {
   return new ShellNetworkDelegate;
 }
 
 net::ProxyConfigService* ShellURLRequestContextGetter::GetProxyConfigService() {
   return net::ProxyService::CreateSystemProxyConfigService(
-      io_loop_->task_runner(), file_loop_->task_runner());
+             io_loop_->task_runner(), file_loop_->task_runner())
+      .get();

[Randy Smith (Not in Mondays), 2015/08/24 21:58:19]

I think this is broken.  What'll happen is the
net::ProxyService::CreateSystemProxyConfigService will return a scoped_ptr<>,
which this routine will get the value of, and then the scoped_ptr will go out of
scope and the underlying object will be deleted.  

.release() will avoid the double free and appropriately gasket between the two
interfaces (since this function passes ownership back, just without the
scoped_ptr<>) but the ideal would be to base your CL on my CL so that you could
just do the return and the scoped_ptr<> would go back up the stack.  

In case you don't know how to do that: Create a clean branch off of master
(Randy_<cl#> or something--name's arbitrary).  Do a "git cl patch 1290243007". 
Then shift over to your branch and do a "git merge Randy_<cl#>".  There'll be
conflicts (at least here, I think :-}), resolve them and commit the merge.  Then
do "git branch --set-upstream-to=Randy_<cl#>".  Then "git cl upload" with some
descriptive text for the patchset.

The result will be a diff in Rietveld which is the diff from my patch, but when
you submit try jobs it'll automatically pull in my patch before running the try
job.  Which is convenient for this sort of change.

 }
 
 net::ProxyService* ShellURLRequestContextGetter::GetProxyService() {
   // TODO(jam): use v8 if possible, look at chrome code.
   return net::ProxyService::CreateUsingSystemProxyResolver(
-      proxy_config_service_.release(), 0, url_request_context_->net_log());
+      proxy_config_service_.Pass(), 0, url_request_context_->net_log());
 }
 
 net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!url_request_context_) {
     const base::CommandLine& command_line =
         *base::CommandLine::ForCurrentProcess();
 
     url_request_context_.reset(new net::URLRequestContext());
@@ skipping 127 matching lines @@
 scoped_refptr<base::SingleThreadTaskRunner>
     ShellURLRequestContextGetter::GetNetworkTaskRunner() const {
   return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
 }
 
 net::HostResolver* ShellURLRequestContextGetter::host_resolver() {
   return url_request_context_->host_resolver();
 }
 
 }  // namespace content