Rename TARGET_OS_* to HOST_OS_*.

runtime/bin/secure_socket_boringssl.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #if !defined(DART_IO_DISABLED) && !defined(DART_IO_SECURE_SOCKET_DISABLED)
 
 #include "platform/globals.h"
-#if defined(TARGET_OS_ANDROID) || defined(TARGET_OS_LINUX) ||                  \
-    defined(TARGET_OS_WINDOWS) || defined(TARGET_OS_FUCHSIA)
+#if defined(HOST_OS_ANDROID) || defined(HOST_OS_LINUX) ||                      \
+    defined(HOST_OS_WINDOWS) || defined(HOST_OS_FUCHSIA)
 
 #include "bin/secure_socket.h"
 #include "bin/secure_socket_boringssl.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
@@ skipping 845 matching lines @@
   if (commandline_root_certs_file != NULL) {
     LoadRootCertFile(context, commandline_root_certs_file);
     return;
   }
 
   if (commandline_root_certs_cache != NULL) {
     LoadRootCertCache(context, commandline_root_certs_cache);
     return;
   }
 
-#if defined(TARGET_OS_ANDROID)
+#if defined(HOST_OS_ANDROID)
   // On Android, we don't compile in the trusted root certificates. Insead,
   // we use the directory of trusted certificates already present on the device.
   // This saves ~240KB from the size of the binary. This has the drawback that
   // SSL_do_handshake will synchronously hit the filesystem looking for root
   // certs during its trust evaluation. We call SSL_do_handshake directly from
   // the Dart thread so that Dart code can be invoked from the "bad certificate"
   // callback called by SSL_do_handshake.
   const char* android_cacerts = "/system/etc/security/cacerts";
   LoadRootCertCache(context, android_cacerts);
   return;
-#elif defined(TARGET_OS_LINUX)
+#elif defined(HOST_OS_LINUX)
   // On Linux, we use the compiled-in trusted certs as a last resort. First,
   // we try to find the trusted certs in various standard locations. A good
   // discussion of the complexities of this endeavor can be found here:
   //
   // https://www.happyassassin.net/2015/01/12/a-note-about-ssltls-trusted-certificate-stores-and-platforms/
   const char* bundle = "/etc/pki/tls/certs/ca-bundle.crt";
   const char* cachedir = "/etc/ssl/certs";
   if (File::Exists(bundle)) {
     LoadRootCertFile(context, bundle);
     return;
   }
 
   if (Directory::Exists(cachedir) == Directory::EXISTS) {
     LoadRootCertCache(context, cachedir);
     return;
   }
-#endif  // defined(TARGET_OS_ANDROID)
+#endif  // defined(HOST_OS_ANDROID)
 
   // Fall back on the compiled-in certs if the standard locations don't exist,
   // or we aren't on Linux.
   if (SSL_LOG_STATUS) {
     Log::Print("Trusting compiled-in roots\n");
   }
   AddCompiledInCerts(context);
 }
 
 
@@ skipping 878 matching lines @@
         Log::Print("WriteEncrypted  BIO_read wrote %d bytes\n",
                    bytes_processed);
     }
   }
   return bytes_processed;
 }
 
 }  // namespace bin
 }  // namespace dart
 
-#endif  // defined(TARGET_OS_LINUX)
+#endif  // defined(HOST_OS_LINUX)
 
 #endif  // !defined(DART_IO_DISABLED) &&
         // !defined(DART_IO_SECURE_SOCKET_DISABLED)