Android: Allow compiling browser without Java UI

chrome/browser/net/chrome_network_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/net/chrome_network_delegate.h"
 
 #include <stdlib.h>
 
 #include <vector>
 
@@ skipping 38 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/log/net_log.h"
 #include "net/url_request/url_request.h"
 
-#if defined(OS_ANDROID)
+#if defined(ANDROID_JAVA_UI)

[Ted C, 2015/11/30 19:39:05]

it is really weird to see a UI ifdef in the network delegate.

I think we really need to look at each one of these individually and make sure
this is the right decision (and I certainly am not the one to be able to say in
many cases).

I think this is fine to get something progressing, but I don't really know how
we can make sure we don't forget and let something fall through the cracks.

[no sievers, 2015/11/30 23:56:34]

I debated decorating a lot of this code with TODOs. But I don't think it adds
much. 
I guess I should have explained that my plan was:
1) strip out all Java
2) bring shared/wanted stuff in bit by bit while potentially reorganizing the
code a bit (think deps rules, directory structure, gn/gyp which currently just
specifies one JAVA_IN_DIR)

This works better to unblock people because most of the missing Java code just
breaks (or changes) some specific feature, but we should still be able to build
the main browser.

 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/precache/precache_manager_factory.h"
 #include "components/precache/content/precache_manager.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #include "chrome/common/chrome_switches.h"
 #endif
 
@@ skipping 29 matching lines @@
 void ForceGoogleSafeSearchCallbackWrapper(
     const net::CompletionCallback& callback,
     net::URLRequest* request,
     GURL* new_url,
     int rv) {
   if (rv == net::OK && new_url->is_empty())
     safe_search_util::ForceGoogleSafeSearch(request, new_url);
   callback.Run(rv);
 }
 
-#if defined(OS_ANDROID)
+#if defined(ANDROID_JAVA_UI)
 void RecordPrecacheStatsOnUIThread(const GURL& url,
                                    const GURL& referrer,
                                    base::TimeDelta latency,
                                    const base::Time& fetch_time,
                                    int64 size,
                                    bool was_cached,
                                    void* profile_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!g_browser_process->profile_manager()->IsValidProfile(profile_id))
     return;
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
 
   precache::PrecacheManager* precache_manager =
       precache::PrecacheManagerFactory::GetForBrowserContext(profile);
   // |precache_manager| could be NULL if the profile is off the record.
   if (!precache_manager || !precache_manager->IsPrecachingAllowed())
     return;
 
   precache_manager->RecordStatsForFetch(url, referrer, latency, fetch_time,
                                         size, was_cached);
 }
-#endif  // defined(OS_ANDROID)
+#endif  // defined(ANDROID_JAVA_UI)
 
 void ReportInvalidReferrerSendOnUI() {
   base::RecordAction(
       base::UserMetricsAction("Net.URLRequest_StartJob_InvalidReferrer"));
 }
 
 void ReportInvalidReferrerSend(const GURL& target_url,
                                const GURL& referrer_url) {
   LOG(ERROR) << "Cancelling request to " << target_url
              << " with invalid referrer " << referrer_url;
@@ skipping 376 matching lines @@
 #endif
   RecordNetworkErrorHistograms(request);
   if (started) {
     // Only call in for requests that were started, to obey the precondition
     // that RecordCacheStateStats can only be called on requests for which
     // OnResponseStarted was called.
     RecordCacheStateStats(request);
   }
 
   if (request->status().status() == net::URLRequestStatus::SUCCESS) {
-#if defined(OS_ANDROID)
+#if defined(ANDROID_JAVA_UI)
     // For better accuracy, we use the actual bytes read instead of the length
     // specified with the Content-Length header, which may be inaccurate,
     // or missing, as is the case with chunked encoding.
     int64 received_content_length = request->received_response_content_length();
     base::TimeDelta latency = base::TimeTicks::Now() - request->creation_time();
 
     // Record precache metrics when a fetch is completed successfully, if
     // precaching is allowed.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&RecordPrecacheStatsOnUIThread, request->url(),
                    GURL(request->referrer()), latency, base::Time::Now(),
                    received_content_length, request->was_cached(), profile_));
-#endif  // defined(OS_ANDROID)
+#endif  // defined(ANDROID_JAVA_UI)
     extensions_delegate_->OnCompleted(request, started);
   } else if (request->status().status() == net::URLRequestStatus::FAILED ||
              request->status().status() == net::URLRequestStatus::CANCELED) {
     extensions_delegate_->OnCompleted(request, started);
   } else {
     NOTREACHED();
   }
   if (domain_reliability_monitor_)
     domain_reliability_monitor_->OnCompleted(request, started);
   RecordRequestSourceBandwidth(request, started);
@@ skipping 188 matching lines @@
   if (!data_use_aggregator_)
     return;
 
   if (is_data_usage_off_the_record_) {
     data_use_aggregator_->ReportOffTheRecordDataUse(tx_bytes, rx_bytes);
     return;
   }
 
   data_use_aggregator_->ReportDataUse(request, tx_bytes, rx_bytes);
 }