Make PPB_Flash_Proxy::GetLocalTimeZoneOffset()'s cache aware of the input time.

ppapi/proxy/ppb_flash_proxy.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 "ppapi/proxy/ppb_flash_proxy.h"
 
+#include <math.h>
+
 #include <limits>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "ppapi/c/dev/ppb_font_dev.h"
 #include "ppapi/c/dev/ppb_var_deprecated.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_resource.h"
@@ skipping 23 matching lines @@
 #include "ppapi/thunk/resource_creation_api.h"
 
 using ppapi::thunk::EnterInstanceNoLock;
 using ppapi::thunk::EnterResourceNoLock;
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
+// Returns true if |t1| and |t2| are times in the same minute.
+bool InSameMinute(PP_Time t1, PP_Time t2) {
+  return floor(t1 / 60.0) == floor(t2 / 60.0);
+}
+
 IPC::PlatformFileForTransit PlatformFileToPlatformFileForTransit(
     Dispatcher* dispatcher,
     int32_t* error,
     base::PlatformFile file) {
   if (*error != PP_OK)
     return IPC::InvalidPlatformFileForTransit();
   IPC::PlatformFileForTransit out_handle =
       dispatcher->ShareHandleWithRemote(file, true);
   if (out_handle == IPC::InvalidPlatformFileForTransit())
     *error = PP_ERROR_NOACCESS;
@@ skipping 164 matching lines @@
   dispatcher()->Send(msg);
 }
 
 void PPB_Flash_Proxy::QuitMessageLoop(PP_Instance instance) {
   dispatcher()->Send(new PpapiHostMsg_PPBFlash_QuitMessageLoop(
       API_ID_PPB_FLASH, instance));
 }
 
 double PPB_Flash_Proxy::GetLocalTimeZoneOffset(PP_Instance instance,
                                                PP_Time t) {
-  static double s_local_offset = 0.0;
+  static double s_cached_t = 0.0;
+  static double s_cached_local_offset = 0.0;
   static int64 s_last_updated = std::numeric_limits<int64>::min();
 
   // Cache the local offset for ten seconds, since it's slow on XP and Linux.
   const int64 kMaxCachedLocalOffsetAgeInSeconds = 10;
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks expiration =
       base::TimeTicks::FromInternalValue(s_last_updated) +
       base::TimeDelta::FromSeconds(kMaxCachedLocalOffsetAgeInSeconds);
-  if (now < expiration)
-    return s_local_offset;
+  // Use cached offset if cache hasn't expired and |t| is in the same minute as
+  // the time for the cached offset (assume offsets change on minute
+  // boundaries).
+  if (now < expiration && InSameMinute(t, s_cached_t))
+    return s_cached_local_offset;
 
+  s_cached_t = t;
   s_last_updated = now.ToInternalValue();
   // TODO(shess): Figure out why OSX needs the access, the sandbox
   // warmup should handle it.  http://crbug.com/149006
 #if defined(OS_LINUX) || defined(OS_MACOSX)
   // On Linux localtime needs access to the filesystem, which is prohibited
   // by the sandbox. It would be better to go directly to the browser process
   // for this message rather than proxy it through some instance in a renderer.
   dispatcher()->Send(new PpapiHostMsg_PPBFlash_GetLocalTimeZoneOffset(
-      API_ID_PPB_FLASH, instance, t, &s_local_offset));
+      API_ID_PPB_FLASH, instance, t, &s_cached_local_offset));
 #else
   base::Time cur = PPTimeToTime(t);
   base::Time::Exploded exploded = { 0 };
   base::Time::Exploded utc_exploded = { 0 };
   cur.LocalExplode(&exploded);
   cur.UTCExplode(&utc_exploded);
   if (exploded.HasValidValues() && utc_exploded.HasValidValues()) {
     base::Time adj_time = base::Time::FromUTCExploded(exploded);
     base::Time cur = base::Time::FromUTCExploded(utc_exploded);
-    s_local_offset = (adj_time - cur).InSecondsF();
+    s_cached_local_offset = (adj_time - cur).InSecondsF();
   } else {
-    s_local_offset = 0.0;
+    s_cached_local_offset = 0.0;
   }
 #endif
 
-  return s_local_offset;
+  return s_cached_local_offset;
 }
 
 PP_Bool PPB_Flash_Proxy::IsRectTopmost(PP_Instance instance,
                                        const PP_Rect* rect) {
   PP_Bool result = PP_FALSE;
   dispatcher()->Send(new PpapiHostMsg_PPBFlash_IsRectTopmost(
       API_ID_PPB_FLASH, instance, *rect, &result));
   return result;
 }
 
@@ skipping 600 matching lines @@
   // It's rarely used enough that we just request this interface when needed.
   const PPB_Flash_Print_1_0* print_interface =
       static_cast<const PPB_Flash_Print_1_0*>(
           dispatcher()->local_get_interface()(PPB_FLASH_PRINT_INTERFACE_1_0));
   if (print_interface)
     print_interface->InvokePrinting(instance);
 }
 
 }  // namespace proxy
 }  // namespace ppapi