Compile src/net for PNaCl

net/base/net_util.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 "net/base/net_util.h"
 
 #include <algorithm>
 #include <iterator>
 #include <map>
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <iphlpapi.h>
 #include <winsock2.h>
 #pragma comment(lib, "iphlpapi.lib")
 #elif defined(OS_POSIX)
 #include <fcntl.h>
-#if !defined(OS_ANDROID)
+#if !defined(OS_ANDROID) && !defined(OS_NACL)
 #include <ifaddrs.h>
 #endif
+#if !defined(OS_NACL)
 #include <net/if.h>
+#endif
 #include <netdb.h>
 #include <netinet/in.h>

[Ryan Sleevi, 2014/03/06 22:02:17]

Seems like this should be reworded as

#elif defined(OS_POSIX)
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#if !defined(OS_NACL)
#include <net/if.h>
#if !defined(OS_ANDROID)
#include <ifaddrs.h>
#endif
#endif
#endif

Unless I've missed somewhere that order matters.

This is to match
http://www.chromium.org/developers/coding-style#TOC-Platform-specific-code

[Sergey Ulanov, 2014/03/21 19:34:41]

Done.

 #endif
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/string_escape.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "base/values.h"
+#if !defined(OS_NACL)
 #include "grit/net_resources.h"
+#endif

[Ryan Sleevi, 2014/03/06 22:02:17]

Likewise, it seems like this, lines 64-66, and 72-74 should all be moved to line
83, per
http://www.chromium.org/developers/coding-style#TOC-Platform-specific-code

[Sergey Ulanov, 2014/03/21 19:34:41]

Done.

 #include "url/gurl.h"
 #include "url/url_canon.h"
 #include "url/url_canon_ip.h"
 #include "url/url_parse.h"
 #if defined(OS_ANDROID)
 #include "net/android/network_library.h"
 #endif
 #include "net/base/dns_util.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
@@ skipping 925 matching lines @@
 
 size_t GetCountOfExplicitlyAllowedPorts() {
   return g_explicitly_allowed_ports.Get().size();
 }
 
 GURL FilePathToFileURL(const base::FilePath& path) {
   // Produce a URL like "file:///C:/foo" for a regular file, or
   // "file://///server/path" for UNC. The URL canonicalizer will fix up the
   // latter case to be the canonical UNC form: "file://server/path"
   base::FilePath::StringType url_string(kFileURLPrefix);
+#if !defined(OS_NACL)
   if (!path.IsAbsolute()) {
     base::FilePath current_dir;
     PathService::Get(base::DIR_CURRENT, &current_dir);
     url_string.append(current_dir.value());
     url_string.push_back(base::FilePath::kSeparators[0]);
   }
+#endif
   url_string.append(path.value());
 
   // Now do replacement of some characters. Since we assume the input is a
   // literal filename, anything the URL parser might consider special should
   // be escaped here.
 
   // must be the first substitution since others will introduce percents as the
   // escape character
   ReplaceSubstringsAfterOffset(&url_string, 0,
       FILE_PATH_LITERAL("%"), FILE_PATH_LITERAL("%25"));
@@ skipping 68 matching lines @@
     canon_host_output.Complete();
     DCHECK_EQ(host_info->out_host.len, static_cast<int>(canon_host.length()));
   } else {
     // Empty host, or canonicalization failed.  We'll return empty.
     canon_host.clear();
   }
 
   return canon_host;
 }
 
+#if !defined(OS_NACL)
 std::string GetDirectoryListingHeader(const base::string16& title) {
   static const base::StringPiece header(
       NetModule::GetResource(IDR_DIR_HEADER_HTML));
   // This can be null in unit tests.
   DLOG_IF(WARNING, header.empty()) <<
       "Missing resource: directory listing header";
 
   std::string result;
   if (!header.empty())
     result.assign(header.data(), header.size());
 
   result.append("<script>start(");
   base::EscapeJSONString(title, true, &result);
   result.append(");</script>\n");
 
   return result;
 }
+#endif
 
 inline bool IsHostCharAlphanumeric(char c) {
   // We can just check lowercase because uppercase characters have already been
   // normalized.
   return ((c >= 'a') && (c <= 'z')) || ((c >= '0') && (c <= '9'));
 }
 
 bool IsCanonicalizedHostCompliant(const std::string& host,
                                   const std::string& desired_tld) {
   if (host.empty())
@@ skipping 22 matching lines @@
       } else {
         return false;
       }
     }
   }
 
   return most_recent_component_started_alphanumeric ||
       (!desired_tld.empty() && IsHostCharAlphanumeric(desired_tld[0]));
 }
 
+#if !defined(OS_NACL)
 std::string GetDirectoryListingEntry(const base::string16& name,
                                      const std::string& raw_bytes,
                                      bool is_dir,
                                      int64 size,
                                      Time modified) {
   std::string result;
   result.append("<script>addRow(");
   base::EscapeJSONString(name, true, &result);
   result.append(",");
   if (raw_bytes.empty()) {
@@ skipping 19 matching lines @@
   // |modified| can be NULL in FTP listings.
   if (!modified.is_null()) {
     modified_str = base::TimeFormatShortDateAndTime(modified);
   }
   base::EscapeJSONString(modified_str, true, &result);
 
   result.append(");</script>\n");
 
   return result;
 }
+#endif  // !defined(OS_NACL)
 
 base::string16 StripWWW(const base::string16& text) {
   const base::string16 www(base::ASCIIToUTF16("www."));
   return StartsWith(text, www, true) ? text.substr(www.length()) : text;
 }
 
 base::string16 StripWWWFromHost(const GURL& url) {
   DCHECK(url.is_valid());
   return StripWWW(base::ASCIIToUTF16(url.host()));
 }
@@ skipping 44 matching lines @@
     *file_path = file_path->DirName();
     if (file_path->value() == base::FilePath::kCurrentDirectory) {
       *file_path = base::FilePath(leaf_name);
     } else {
       *file_path = file_path->Append(leaf_name);
     }
   }
 #endif
 }
 
+#if !defined(OS_NACL)
 base::string16 GetSuggestedFilename(const GURL& url,
                                     const std::string& content_disposition,
                                     const std::string& referrer_charset,
                                     const std::string& suggested_name,
                                     const std::string& mime_type,
                                     const std::string& default_name) {
   // TODO: this function to be updated to match the httpbis recommendations.
   // Talk to abarth for the latest news.
 
   // We don't translate this fallback string, "download". If localization is
@@ skipping 88 matching lines @@
   // normalized names. Otherwise, we won't be able to handle files with NFD
   // utf8 encoded characters in name.
   file_util::NormalizeFileNameEncoding(&generated_name);
 #endif
 
   DCHECK(!generated_name.empty());
 
   return generated_name;
 }
 
+#endif  // !defined(OS_NACL)
+
 bool IsPortAllowedByDefault(int port) {
   int array_size = arraysize(kRestrictedPorts);
   for (int i = 0; i < array_size; i++) {
     if (kRestrictedPorts[i] == port) {
       return false;
     }
   }
   return true;
 }
 
@@ skipping 288 matching lines @@
                                       uint16 port) {
   return IPAddressToStringWithPort(&addr.front(), addr.size(), port);
 }
 
 std::string IPAddressToPackedString(const IPAddressNumber& addr) {
   return std::string(reinterpret_cast<const char *>(&addr.front()),
                      addr.size());
 }
 
 std::string GetHostName() {
+#if defined(OS_NACL)
+  NOTIMPLEMENTED();
+  return std::string();
+#else  // defined(OS_NACL)
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
 
   // Host names are limited to 255 bytes.
   char buffer[256];
   int result = gethostname(buffer, sizeof(buffer));
   if (result != 0) {
     DVLOG(1) << "gethostname() failed with " << result;
     buffer[0] = '\0';
   }
   return std::string(buffer);
+#endif  // !defined(OS_NACL)
 }
 
 void GetIdentityFromURL(const GURL& url,
                         base::string16* username,
                         base::string16* password) {
   UnescapeRule::Type flags =
       UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS;
   *username = UnescapeAndDecodeUTF8URLComponent(url.username(), flags, NULL);
   *password = UnescapeAndDecodeUTF8URLComponent(url.password(), flags, NULL);
 }
@@ skipping 245 matching lines @@
       g_explicitly_allowed_ports.Get().find(port_);
   if (it != g_explicitly_allowed_ports.Get().end())
     g_explicitly_allowed_ports.Get().erase(it);
   else
     NOTREACHED();
 }
 
 bool HaveOnlyLoopbackAddresses() {
 #if defined(OS_ANDROID)
   return android::HaveOnlyLoopbackAddresses();
+#elif defined(OS_NACL)
+  NOTIMPLEMENTED();
+  return false;
 #elif defined(OS_POSIX)
   struct ifaddrs* interface_addr = NULL;
   int rv = getifaddrs(&interface_addr);
   if (rv != 0) {
     DVLOG(1) << "getifaddrs() failed with errno = " << errno;
     return false;
   }
 
   bool result = true;
   for (struct ifaddrs* interface = interface_addr;
@@ skipping 262 matching lines @@
   }
   return a1.size() * CHAR_BIT;
 }
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 }  // namespace net