Send screenshots back to the client for debugging

chrome/test/webdriver/session.cc

 // Copyright (c) 2011 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/test/webdriver/session_manager.h"
 
 #include <sstream>
 #include <vector>
 
+#include "base/base64.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "base/process.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
+#include "base/scoped_temp_dir.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 28 matching lines @@
   bool success = false;
   if (thread_.Start()) {
     RunSessionTask(NewRunnableMethod(
         this,
         &Session::InitOnSessionThread,
         browser_dir,
         &success));
   } else {
     LOG(ERROR) << "Cannot start session thread";
   }
+
   if (!success)
     delete this;
+
   return success;
 }
 
 void Session::Terminate() {
   RunSessionTask(NewRunnableMethod(
       this,
       &Session::TerminateOnSessionThread));
   delete this;
 }
 
@@ skipping 268 matching lines @@
 bool Session::GetWindowIds(std::vector<int>* window_ids) {
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::GetTabIds,
       window_ids,
       &success));
   return success;
 }
 
+bool Session::CaptureEntirePageAsPNG(const FilePath& path) {
+  bool success = false;
+  RunSessionTask(NewRunnableMethod(
+      automation_.get(),
+      &Automation::CaptureEntirePageAsPNG,
+      current_window_id_,
+      path,
+      &success));
+  return success;
+}
+
+bool Session::ScreenshotAsBase64(std::string* screenshot) {
+  ScopedTempDir screenshots_dir;
+
+  // Create a temp directory for screenshots.
+  if (!screenshots_dir.CreateUniqueTempDir()) {
+    LOG(ERROR) << "Could not make a temp directory for screenshots";
+    return false;
+  }
+
+  // Generate a temp file name for the screenshot
+  std::string file = screenshots_dir.path().value() + "screen";

[kkania, 2011/03/07 18:15:17]

instead of all this code, you should be able to just do
screenshots_dir.path().AppendASCII("screen")

[Joe, 2011/03/11 22:12:48]

That would keep the file around until the session is closed rather than cleaning
it up once the shot is sent back.  It's probably cleaner to remove the file once
it is not needed anymore.

On 2011/03/07 18:15:17, kkania wrote:

+
+#ifdef OS_POSIX
+  FilePath path = FilePath(file.c_str());
+#elif OS_WIN
+  FilePath path = FilePath(ASCIIToWide(file.s_ctr()));
+#endif
+
+  // Capture the current tab as a PNG file.
+  if (!CaptureEntirePageAsPNG(path)) {
+    LOG(ERROR) << "Capturing tab page as PNG failed";
+    return false;
+  }
+
+  std::string raw_bytes;
+  if (!file_util::ReadFileToString(path, &raw_bytes)) {
+    LOG(ERROR) << "Opening PNG file failed";
+    return false;
+  }
+
+  // Make a base64 encoded string for the raw PNG data
+  if (!base::Base64Encode(raw_bytes, screenshot)) {
+    LOG(ERROR) << "Encoding the PNG to base64 format failed";
+    return false;
+  }
+
+  return true;
+}
+
 ErrorCode Session::SwitchToWindow(const std::string& name) {
   int switch_to_id = 0;
   int name_no = 0;
   if (base::StringToInt(name, &name_no)) {
     bool does_exist = false;
     RunSessionTask(NewRunnableMethod(
         automation_.get(),
         &Automation::DoesTabExist,
         name_no,
         &does_exist));
@@ skipping 185 matching lines @@
   if (!automation_.get())
     return true;
   bool success = false;
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::WaitForAllTabsToStopLoading,
       &success));
   return success;
 }
 
+std::string Session::Id() const {
+  return id_;
+}
+
+int Session::ImplicitWait() const {
+  return implicit_wait_;
+}
+
+void Session::SetImplicitWait(const int timeout) {
+  implicit_wait_ = timeout > 0 ? timeout : 0;
+}
+
+Session::InputSpeed Session::Speed() const {
+  return speed_;
+}
+
+void Session::SetSpeed(const InputSpeed& speed) {
+  speed_ = speed;
+}
+
+std::string Session::CurrentFrameXPath() const {
+  return current_frame_xpath_;
+}
+
+void Session::SetCurrentFrameXPath(const std::string& xpath) {

[kkania, 2011/03/07 18:15:17]

Why did you change these func names?

+  current_frame_xpath_ = xpath;
+}
+
+int Session::CurrentWindowId() const {
+  return current_window_id_;
+}
+
 void Session::RunSessionTask(Task* task) {
   base::WaitableEvent done_event(false, false);
   thread_.message_loop_proxy()->PostTask(FROM_HERE, NewRunnableMethod(
       this,
       &Session::RunSessionTaskOnSessionThread,
       task,
       &done_event));
   done_event.Wait();
 }
 
@@ skipping 187 matching lines @@
       }
     } else {
       LOG(ERROR) << "Location atom returned non-dictionary type";
       code = kUnknownError;
     }
   }
   return code;
 }
 
 }  // namespace webdriver