Add an API to allow JavaScript to determine the framerate of individual dynam...

core/win/d3d9/texture_d3d9.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 242 matching lines @@
   unsigned blocks_down = (src_height + 3) / 4;
   unsigned bytes_per_block = format == Texture::DXT1 ? 8 : 16;
   unsigned bytes_per_row = bytes_per_block * blocks_across;
   for (unsigned yy = 0; yy < blocks_down; ++yy) {
     memcpy(dst, src, bytes_per_row);
     src += bytes_per_row;
     dst += dst_pitch;
   }
 }
 
-void SetTextureRect(
+bool SetTextureRect(
     ServiceLocator* service_locator,
     IDirect3DTexture9* d3d_texture,
     Texture::Format format,
     int level,
     unsigned dst_left,
     unsigned dst_top,
     unsigned src_width,
     unsigned src_height,
     const void* src_data,
     int src_pitch) {
   DCHECK(src_data);
   bool compressed = Texture::IsCompressedFormat(format);
 
   RECT rect = {dst_left, dst_top, dst_left + src_width, dst_top + src_height};
   D3DLOCKED_RECT out_rect = {0};
 
   if (!HR(d3d_texture->LockRect(
       level, &out_rect, compressed ? NULL : &rect, 0))) {
     O3D_ERROR(service_locator) << "Failed to Lock Texture2D (D3D9)";
-    return;
+    return false;
   }
 
   const uint8* src = static_cast<const uint8*>(src_data);
   uint8* dst = static_cast<uint8*>(out_rect.pBits);
   if (!compressed) {
     SetTextureRectUncompressed(format, src, src_pitch, src_width, src_height,
                                dst, out_rect.Pitch);
   } else {
     SetTextureRectCompressed(
         format, src, src_width, src_height, dst, out_rect.Pitch);
   }
   if (!HR(d3d_texture->UnlockRect(level))) {
     O3D_ERROR(service_locator) << "Failed to Unlock Texture2D (D3D9)";
-    return;
+    return false;
   }
+  return true;
 }
 
-void SetTextureFaceRect(
+bool SetTextureFaceRect(
     ServiceLocator* service_locator,
     IDirect3DCubeTexture9* d3d_texture,
     Texture::Format format,
     TextureCUBE::CubeFace face,
     int level,
     unsigned dst_left,
     unsigned dst_top,
     unsigned src_width,
     unsigned src_height,
     const void* src_data,
     int src_pitch) {
   DCHECK(src_data);
   bool compressed = Texture::IsCompressedFormat(format);
 
   RECT rect = {dst_left, dst_top, dst_left + src_width, dst_top + src_height};
   D3DLOCKED_RECT out_rect = {0};
 
   D3DCUBEMAP_FACES d3d_face = DX9CubeFace(face);
 
   if (!HR(d3d_texture->LockRect(
       d3d_face, level, &out_rect, compressed ? NULL : &rect, 0))) {
     O3D_ERROR(service_locator) << "Failed to Lock TextureCUBE (D3D9)";
-    return;
+    return false;
   }
 
   const uint8* src = static_cast<const uint8*>(src_data);
   uint8* dst = static_cast<uint8*>(out_rect.pBits);
   if (!compressed) {
     SetTextureRectUncompressed(format, src, src_pitch, src_width, src_height,
                                dst, out_rect.Pitch);
   } else {
     SetTextureRectCompressed(
         format, src, src_width, src_height, dst, out_rect.Pitch);
   }
   if (!HR(d3d_texture->UnlockRect(d3d_face, level))) {
     O3D_ERROR(service_locator) << "Failed to Unlock TextureCUBE (D3D9)";
-    return;
+    return false;
   }
+  return true;
 }
 
 }  // unnamed namespace
 
 // Constructs a 2D texture object from the given (existing) D3D 2D texture.
 Texture2DD3D9::Texture2DD3D9(ServiceLocator* service_locator,
                              IDirect3DTexture9* tex,
                              Texture::Format format,
                              int levels,
                              int width,
@@ skipping 193 matching lines @@
   bool entire_rect = dst_left == 0 && dst_top == 0 &&
                      src_width == mip_width && src_height == mip_height;
   bool compressed = IsCompressed();
 
   if (compressed && !entire_rect) {
     O3D_ERROR(service_locator())
         << "SetRect must be full rectangle for compressed textures";
     return;
   }
 
+  bool success = true;
   if (resize_to_pot_) {
     DCHECK(backing_bitmap_->image_data());
     DCHECK(!compressed);
     // We need to update the backing mipmap and then use that to update the
     // texture.
     backing_bitmap_->SetRect(
         level, dst_left, dst_top, src_width, src_height, src_data, src_pitch);
     UpdateBackedMipLevel(level);
   } else {
-    SetTextureRect(service_locator(),
-                   d3d_texture_,
-                   format(),
-                   level,
-                   dst_left,
-                   dst_top,
-                   src_width,
-                   src_height,
-                   src_data,
-                   src_pitch);
+    success = SetTextureRect(service_locator(),
+                             d3d_texture_,
+                             format(),
+                             level,
+                             dst_left,
+                             dst_top,
+                             src_width,
+                             src_height,
+                             src_data,
+                             src_pitch);
+  }
+  if (success && level == 0) {
+    TextureUpdated();
   }
 }
 
 // Locks the given mipmap level of this texture for loading from main memory,
 // and returns a pointer to the buffer.
 bool Texture2DD3D9::PlatformSpecificLock(
     int level, void** texture_data, int* pitch, Texture::AccessMode mode) {
   DCHECK(texture_data);
   DCHECK(pitch);
   DCHECK_GE(level, 0);
@@ skipping 288 matching lines @@
   bool entire_rect = dst_left == 0 && dst_top == 0 &&
                      src_width == mip_width && src_height == mip_height;
   bool compressed = IsCompressed();
 
   if (compressed && !entire_rect) {
     O3D_ERROR(service_locator())
         << "SetRect must be full rectangle for compressed textures";
     return;
   }
 
+  bool success = true;
   if (resize_to_pot_) {
     Bitmap* backing_bitmap = backing_bitmaps_[face].Get();
     DCHECK(backing_bitmap->image_data());
     DCHECK(!compressed);
     // We need to update the backing mipmap and then use that to update the
     // texture.
     backing_bitmap->SetRect(
         level, dst_left, dst_top, src_width, src_height, src_data, src_pitch);
     UpdateBackedMipLevel(face, level);
   } else {
-    SetTextureFaceRect(service_locator(),
-                       d3d_cube_texture_,
-                       format(),
-                       face,
-                       level,
-                       dst_left,
-                       dst_top,
-                       src_width,
-                       src_height,
-                       src_data,
-                       src_pitch);
+    success = SetTextureFaceRect(service_locator(),
+                                 d3d_cube_texture_,
+                                 format(),
+                                 face,
+                                 level,
+                                 dst_left,
+                                 dst_top,
+                                 src_width,
+                                 src_height,
+                                 src_data,
+                                 src_pitch);
+  }
+  if (success && level == 0) {
+    TextureUpdated();
   }
 }
 
 // Locks the given face and mipmap level of this texture for loading from
 // main memory, and returns a pointer to the buffer.
 bool TextureCUBED3D9::PlatformSpecificLock(
     CubeFace face, int level, void** texture_data, int* pitch,
     Texture::AccessMode mode) {
   DCHECK(texture_data);
   DCHECK(pitch);
@@ skipping 67 matching lines @@
                                     &d3d_cube_texture_));
   }
   return true;
 }
 
 const Texture::RGBASwizzleIndices& TextureCUBED3D9::GetABGR32FSwizzleIndices() {
   return g_d3d_abgr32f_swizzle_indices;
 }
 
 }  // namespace o3d