Set clock precision to milliseconds for Datetime->Instant migration (#2999)

Our existing precision is milliseconds so we want to stick with that for
Instants. If we want to increase the precision globally after that we can do so
all in one go post-migration, but for now, it would be a bad thing to have mixed
precision going on just depending on whether a class happens to be migrated yet
or not.

This PR also migrates all existing DateTime.nowUtc() calls to use the Clock
interface, so that when they are migrated they will get the benefit of this
precision-setting as well.

BUG= http://b/496985355

common/src/main/java/google/registry/util/Clock.java

@@ -16,6 +16,8 @@ package google.registry.util;
 
 import java.io.Serializable;
 import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
 import javax.annotation.concurrent.ThreadSafe;
 import org.joda.time.DateTime;
 
@@ -36,4 +38,9 @@ public interface Clock extends Serializable {
 
   /** Returns current Instant (which is always in UTC). */
   Instant now();
+
+  /** Returns the current time as a {@link ZonedDateTime} in UTC. */
+  default ZonedDateTime nowDate() {
+    return ZonedDateTime.ofInstant(now(), ZoneOffset.UTC);
+  }
 }

common/src/main/java/google/registry/util/DateTimeUtils.java

@@ -170,6 +170,12 @@ public abstract class DateTimeUtils {
     return (instant == null) ? null : new DateTime(instant.toEpochMilli(), DateTimeZone.UTC);
   }
 
+  /** Convert a java.time {@link java.time.Instant} to a joda {@link org.joda.time.Instant}. */
+  @Nullable
+  public static org.joda.time.Instant toJodaInstant(@Nullable java.time.Instant instant) {
+    return (instant == null) ? null : org.joda.time.Instant.ofEpochMilli(instant.toEpochMilli());
+  }
+
   public static Instant plusYears(Instant instant, int years) {
     return instant.atZone(ZoneOffset.UTC).plusYears(years).toInstant();
   }

common/src/main/java/google/registry/util/SystemClock.java

@@ -38,6 +38,10 @@ public class SystemClock implements Clock {
 
   @Override
   public Instant now() {
-    return Instant.now();
+    // Truncate to milliseconds to match the precision of Joda DateTime and our database schema
+    // (which uses millisecond precision via DateTimeConverter). This prevents subtle comparison
+    // bugs where a high-precision Instant would be considered "after" a truncated database
+    // timestamp.
+    return Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MILLIS);
   }
 }