Move scoped_cftyperef from base to base/mac, use the new namespace, and name ...

net/proxy/proxy_resolver_mac.cc

 // Copyright (c) 2008 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 "net/proxy/proxy_resolver_mac.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 
 #include "base/logging.h"
 #include "base/mac_util.h"
-#include "base/scoped_cftyperef.h"
+#include "base/mac/scoped_cftyperef.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_info.h"
 #include "net/proxy/proxy_server.h"
 
 namespace {
 
 // Utility function to map a CFProxyType to a ProxyServer::Scheme.
 // If the type is unknown, returns ProxyServer::SCHEME_INVALID.
@@ skipping 31 matching lines @@
 
 namespace net {
 
 // Gets the proxy information for a query URL from a PAC. Implementation
 // inspired by http://developer.apple.com/samplecode/CFProxySupportTool/
 int ProxyResolverMac::GetProxyForURL(const GURL& query_url,
                                      ProxyInfo* results,
                                      CompletionCallback* /*callback*/,
                                      RequestHandle* /*request*/,
                                      const BoundNetLog& net_log) {
-  scoped_cftyperef<CFStringRef> query_ref(
+  base::mac::ScopedCFTypeRef<CFStringRef> query_ref(
       base::SysUTF8ToCFStringRef(query_url.spec()));
-  scoped_cftyperef<CFURLRef> query_url_ref(
+  base::mac::ScopedCFTypeRef<CFURLRef> query_url_ref(
       CFURLCreateWithString(kCFAllocatorDefault,
                             query_ref.get(),
                             NULL));
   if (!query_url_ref.get())
     return ERR_FAILED;
-  scoped_cftyperef<CFStringRef> pac_ref(
+  base::mac::ScopedCFTypeRef<CFStringRef> pac_ref(
       base::SysUTF8ToCFStringRef(
           script_data_->type() == ProxyResolverScriptData::TYPE_AUTO_DETECT ?
               std::string() : script_data_->url().spec()));
-  scoped_cftyperef<CFURLRef> pac_url_ref(
+  base::mac::ScopedCFTypeRef<CFURLRef> pac_url_ref(
       CFURLCreateWithString(kCFAllocatorDefault,
                             pac_ref.get(),
                             NULL));
   if (!pac_url_ref.get())
     return ERR_FAILED;
 
   // Work around <rdar://problem/5530166>. This dummy call to
   // CFNetworkCopyProxiesForURL initializes some state within CFNetwork that is
   // required by CFNetworkExecuteProxyAutoConfigurationURL.
 
   CFArrayRef dummy_result = CFNetworkCopyProxiesForURL(query_url_ref.get(),
                                                        NULL);
   if (dummy_result)
     CFRelease(dummy_result);
 
   // We cheat here. We need to act as if we were synchronous, so we pump the
   // runloop ourselves. Our caller moved us to a new thread anyway, so this is
   // OK to do. (BTW, CFNetworkExecuteProxyAutoConfigurationURL returns a
   // runloop source we need to release despite its name.)
 
   CFTypeRef result = NULL;
   CFStreamClientContext context = { 0, &result, NULL, NULL, NULL };
-  scoped_cftyperef<CFRunLoopSourceRef> runloop_source(
+  base::mac::ScopedCFTypeRef<CFRunLoopSourceRef> runloop_source(
       CFNetworkExecuteProxyAutoConfigurationURL(pac_url_ref.get(),
                                                 query_url_ref.get(),
                                                 ResultCallback,
                                                 &context));
   if (!runloop_source)
     return ERR_FAILED;
 
   const CFStringRef private_runloop_mode =
       CFSTR("org.chromium.ProxyResolverMac");
 
   CFRunLoopAddSource(CFRunLoopGetCurrent(), runloop_source.get(),
                      private_runloop_mode);
   CFRunLoopRunInMode(private_runloop_mode, DBL_MAX, false);
   CFRunLoopRemoveSource(CFRunLoopGetCurrent(), runloop_source.get(),
                         private_runloop_mode);
   DCHECK(result != NULL);
 
   if (CFGetTypeID(result) == CFErrorGetTypeID()) {
     // TODO(avi): do something better than this
     CFRelease(result);
     return ERR_FAILED;
   }
   DCHECK(CFGetTypeID(result) == CFArrayGetTypeID());
-  scoped_cftyperef<CFArrayRef> proxy_array_ref((CFArrayRef)result);
+  base::mac::ScopedCFTypeRef<CFArrayRef> proxy_array_ref((CFArrayRef)result);
 
   // This string will be an ordered list of <proxy-uri> entries, separated by
   // semi-colons. It is the format that ProxyInfo::UseNamedProxy() expects.
   //    proxy-uri = [<proxy-scheme>"://"]<proxy-host>":"<proxy-port>
   // (This also includes entries for direct connection, as "direct://").
   std::string proxy_uri_list;
 
   CFIndex proxy_array_count = CFArrayGetCount(proxy_array_ref.get());
   for (CFIndex i = 0; i < proxy_array_count; ++i) {
     CFDictionaryRef proxy_dictionary =
@@ skipping 32 matching lines @@
   }
 
   if (!proxy_uri_list.empty())
     results->UseNamedProxy(proxy_uri_list);
   // Else do nothing (results is already guaranteed to be in the default state).
 
   return OK;
 }
 
 }  // namespace net