Bar

chrome/browser/tab_contents/thumbnail_generator.cc

 // Copyright (c) 2009 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 "chrome/browser/tab_contents/thumbnail_generator.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/histogram.h"
@@ skipping 173 matching lines @@
       delete callback;
       return;
     }
     // Now, if the backing store didn't exist, we will still try and
     // render asynchronously.
   }
 
   // We are going to render the thumbnail asynchronously now, so keep
   // this callback for later lookup when the rendering is done.
   static int sequence_num = 0;
+  sequence_num++;
   TransportDIB* thumbnail_dib = TransportDIB::Create(
-      desired_size.width() * desired_size.height() * 4, sequence_num++);
+      desired_size.width() * desired_size.height() * 4, sequence_num);
+
+fprintf(stderr, "expecting dib data %d %d %d %d %p\n",
+ page_size.width(), page_size.height(), desired_size.width(), desired_size.height(), thumbnail_dib->memory());
   linked_ptr<AsyncRequestInfo> request_info(new AsyncRequestInfo);
   request_info->callback.reset(callback);
   request_info->thumbnail_dib.reset(thumbnail_dib);
   request_info->renderer = renderer;
-  ThumbnailCallbackMap::value_type new_value(thumbnail_dib->handle(),
-                                             request_info);
+  ThumbnailCallbackMap::value_type new_value(sequence_num, request_info);
   std::pair<ThumbnailCallbackMap::iterator, bool> result =
       callback_map_.insert(new_value);
   if (!result.second) {
     NOTREACHED() << "Callback already registered?";
     return;
   }
 
-  renderer->PaintAtSize(thumbnail_dib->handle(), page_size, desired_size);
+  renderer->PaintAtSize(
+      thumbnail_dib->handle(), sequence_num, page_size, desired_size);
 }
 
 SkBitmap ThumbnailGenerator::GetThumbnailForRenderer(
     RenderWidgetHost* renderer) const {
   WidgetThumbnail* wt = GetDataForHost(renderer);
 
   BackingStore* backing_store = renderer->GetBackingStore(false);
   if (!backing_store) {
     // When we have no backing store, there's no choice in what to use. We
     // have to return either the existing thumbnail or the empty one if there
@@ skipping 63 matching lines @@
     return;  // TODO(brettw) schedule thumbnail generation for this renderer in
              // case we don't get a paint for it after the time slop, but it's
              // still visible.
 
   // Clear the thumbnail, since it's now out of date.
   wt->thumbnail = SkBitmap();
 }
 
 void ThumbnailGenerator::WidgetDidReceivePaintAtSizeAck(
     RenderWidgetHost* widget,
-    const TransportDIB::Handle& dib_handle,
+    int sequence_num,
     const gfx::Size& size) {
+fprintf(stderr, "ThumbnailGenerator got ack %d %d %d\n", size.width(), size.height(), sequence_num);
   // Lookup the callback, run it, and erase it.
-  ThumbnailCallbackMap::iterator item = callback_map_.find(dib_handle);
+  ThumbnailCallbackMap::iterator item = callback_map_.find(sequence_num);
   if (item != callback_map_.end()) {
     TransportDIB* dib = item->second->thumbnail_dib.get();
     DCHECK(dib);
     if (!dib) {
+fprintf(stderr, "not found in map\n");
       return;
     }
 
     // Create an SkBitmap from the DIB.
     SkBitmap non_owned_bitmap;
     SkBitmap result;
 
     // Fill out the non_owned_bitmap with the right config.  Note that
     // this code assumes that the transport dib is a 32-bit ARGB
     // image.
     non_owned_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                                size.width(), size.height());
     non_owned_bitmap.setPixels(dib->memory());
+fprintf(stderr, "received dib data %d %d %p\n", size.width(), size.height(), dib->memory());
 
     // Now alloc/copy the memory so we own it and can pass it around,
     // and the memory won't go away when the DIB goes away.
     // TODO: Figure out a way to avoid this copy?
     non_owned_bitmap.copyTo(&result, SkBitmap::kARGB_8888_Config);
 
+fprintf(stderr, "running callback\n");
     item->second->callback->Run(result);
 
     // We're done with the callback, and with the DIB, so delete both.
     callback_map_.erase(item);
   }
 }
 
 void ThumbnailGenerator::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
@@ skipping 113 matching lines @@
                  &ThumbnailGenerator::ShownDelayHandler);
   }
 }
 
 void ThumbnailGenerator::EraseHostFromShownList(RenderWidgetHost* widget) {
   std::vector<RenderWidgetHost*>::iterator found =
       std::find(shown_hosts_.begin(), shown_hosts_.end(), widget);
   if (found != shown_hosts_.end())
     shown_hosts_.erase(found);
 }