Cleanup: Change some !OS_ANDROID #ifdefs to ENABLE_EXTENSIONS in ChromeResourceDispatcherHostDelega…

chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.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 "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
 
 #include <string>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 144 matching lines @@
 
   if (prerender_contents)
     prerender_contents->AddNetworkBytes(bytes);
 
   prerender::PrerenderManager* prerender_manager =
       GetPrerenderManager(render_process_id, render_view_id);
   if (prerender_manager)
     prerender_manager->AddProfileNetworkBytesIfEnabled(bytes);
 }
 
-#if !defined(OS_ANDROID)
+#if defined(ENABLE_EXTENSIONS)
 void SendExecuteMimeTypeHandlerEvent(scoped_ptr<content::StreamHandle> stream,
                                      int64 expected_content_size,
                                      int render_process_id,
                                      int render_view_id,
                                      const std::string& extension_id,
                                      const std::string& view_id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   content::WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_id, render_view_id);
@@ skipping 12 matching lines @@
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   StreamsPrivateAPI* streams_private = StreamsPrivateAPI::Get(profile);
   if (!streams_private)
     return;
   streams_private->ExecuteMimeTypeHandler(
       extension_id, web_contents, stream.Pass(), view_id,
       expected_content_size);
 }
+#endif  // !defined(ENABLE_EXTENSIONS)
 
+#if !defined(OS_ANDROID)
 void LaunchURL(const GURL& url, int render_process_id, int render_view_id,
                bool user_gesture) {
   // If there is no longer a WebContents, the request may have raced with tab
   // closing. Don't fire the external request. (It may have been a prerender.)
   content::WebContents* web_contents =
       tab_util::GetWebContentsByID(render_process_id, render_view_id);
   if (!web_contents)
     return;
 
   // Do not launch external requests attached to unswapped prerenders.
@@ skipping 349 matching lines @@
 #else
   return false;
 #endif
 }
 
 bool ChromeResourceDispatcherHostDelegate::ShouldInterceptResourceAsStream(
     net::URLRequest* request,
     const std::string& mime_type,
     GURL* origin,
     std::string* payload) {
-#if !defined(OS_ANDROID)
+#if defined(ENABLE_EXTENSIONS)
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   ProfileIOData* io_data =
       ProfileIOData::FromResourceContext(info->GetContext());
   bool profile_is_off_the_record = io_data->IsOffTheRecord();
   const scoped_refptr<const extensions::InfoMap> extension_info_map(
       io_data->GetExtensionInfoMap());
   std::vector<std::string> whitelist = MimeTypesHandler::GetMIMETypeWhitelist();
   // Go through the white-listed extensions and try to use them to intercept
   // the URL request.
   for (size_t i = 0; i < whitelist.size(); ++i) {
@@ skipping 22 matching lines @@
       return true;
     }
   }
 #endif
   return false;
 }
 
 void ChromeResourceDispatcherHostDelegate::OnStreamCreated(
     net::URLRequest* request,
     scoped_ptr<content::StreamHandle> stream) {
-#if !defined(OS_ANDROID)
+#if defined(ENABLE_EXTENSIONS)
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
   std::map<net::URLRequest*, StreamTargetInfo>::iterator ix =
       stream_target_info_.find(request);
   CHECK(ix != stream_target_info_.end());
   content::BrowserThread::PostTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&SendExecuteMimeTypeHandlerEvent, base::Passed(&stream),
                  request->GetExpectedContentSize(),
                  info->GetChildID(), info->GetRouteID(),
                  ix->second.extension_id, ix->second.view_id));
@@ skipping 109 matching lines @@
                                        url_request->GetTotalReceivedBytes()));
   }
 }
 
 // static
 void ChromeResourceDispatcherHostDelegate::
     SetExternalProtocolHandlerDelegateForTesting(
     ExternalProtocolHandler::Delegate* delegate) {
   g_external_protocol_handler_delegate = delegate;
 }