DownloadManager::Observer::OnDownloadCreated

chrome/browser/extensions/api/downloads/downloads_api_unittest.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 <algorithm>
 
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
@@ skipping 150 matching lines @@
     switch (type) {
       case chrome::NOTIFICATION_EXTENSION_DOWNLOADS_EVENT:
         {
           DownloadsNotificationSource* dns =
               content::Source<DownloadsNotificationSource>(source).ptr();
           Event* new_event = new Event(
               dns->profile,
               dns->event_name,
               *content::Details<std::string>(details).ptr(), base::Time::Now());
           events_.push_back(new_event);
+          LOG(INFO) << "occam caught " << new_event->Debug();

[Randy Smith (Not in Mondays), 2012/07/23 18:40:50]

Was this intended to be in the CL proposed for landing?  Without some specific
reason, I think LOG(INFO)s are a bad idea.

[benjhayden, 2012/07/23 18:54:22]

Sorry, was having trouble repro-ing trybot failures and forgot to remove them.

           if (waiting_ &&
               waiting_for_.get() &&
               waiting_for_->Equals(*new_event)) {
             waiting_ = false;
             MessageLoopForUI::current()->Quit();
           }
           break;
         }
       default:
         NOTREACHED();
     }
   }
 
   bool WaitFor(Profile* profile,
                const std::string& event_name,
                const std::string& json_args) {
     waiting_for_.reset(new Event(profile, event_name, json_args, base::Time()));
     for (std::deque<Event*>::const_iterator iter = events_.begin();
          iter != events_.end(); ++iter) {
       if ((*iter)->Equals(*waiting_for_.get()))
         return true;
     }
+    LOG(INFO) << "occam waiting " << waiting_for_->Debug();

[Randy Smith (Not in Mondays), 2012/07/23 18:40:50]

Ditto.

[benjhayden, 2012/07/23 18:54:22]

Done.

     waiting_ = true;
     ui_test_utils::RunMessageLoop();
     bool success = !waiting_;
     if (waiting_) {
       // Print the events that were caught since the last WaitFor() call to help
       // find the erroneous event.
       // TODO(benjhayden) Fuzzy-match and highlight the erroneous event.
       for (std::deque<Event*>::const_iterator iter = events_.begin();
           iter != events_.end(); ++iter) {
         if ((*iter)->caught() > last_wait_) {
@@ skipping 86 matching lines @@
 
   bool WaitFor(const std::string& event_name, const std::string& json_args) {
     return events_listener_->WaitFor(
         current_browser()->profile(), event_name, json_args);
   }
 
   bool WaitForInterruption(DownloadItem* item, int expected_error,
                            const std::string& on_created_event) {
     if (!WaitFor(extension_event_names::kOnDownloadCreated, on_created_event))
       return false;
-    // The item may or may not be interrupted before the onCreated event fires.
-    if (item->IsInterrupted()) {
-      scoped_ptr<base::Value> args(base::JSONReader::Read(on_created_event));
-      base::ListValue* args_list = NULL;
-      base::DictionaryValue* args_dict = NULL;
-      if (!args->GetAsList(&args_list) ||
-          !args_list->GetDictionary(0, &args_dict))
-        return false;
-      args_dict->SetString("state", "interrupted");
-      args_dict->SetInteger("error", expected_error);
-      std::string created_error;
-      base::JSONWriter::Write(args_list, &created_error);
-      // This is not waiting for a different event, it's refining the
-      // expectations on the onCreated event that was just caught. Specifically,
-      // if a DownloadItem is already interrupted by the time the onCreated
-      // event fires, then the onCreated event should already describe the
-      // error.
-      return WaitFor(extension_event_names::kOnDownloadCreated, created_error);
-    } else {
-      return WaitFor(extension_event_names::kOnDownloadChanged,
-          base::StringPrintf("[{\"id\": %d,"
-                              "  \"error\": {\"current\": %d},"
-                              "  \"state\": {"
-                              "    \"previous\": \"in_progress\","
-                              "    \"current\": \"interrupted\"}}]",
-                              item->GetId(),
-                              expected_error));
-    }
+    // Now, onCreated is always fired before interruption.
+    return WaitFor(extension_event_names::kOnDownloadChanged,
+        base::StringPrintf("[{\"id\": %d,"
+                            "  \"error\": {\"current\": %d},"
+                            "  \"state\": {"
+                            "    \"previous\": \"in_progress\","
+                            "    \"current\": \"interrupted\"}}]",
+                            item->GetId(),
+                            expected_error));
   }
 
   std::string GetExtensionURL() {
     return extension_->url().spec();
   }
 
   std::string GetFilename(const char* path) {
     std::string result =
       downloads_directory_.path().AppendASCII(path).AsUTF8Unsafe();
 #if defined(OS_WIN)
@@ skipping 1158 matching lines @@
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
   if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
                           "  \"incognito\": false,"
                           "  \"mime\": \"text/plain\","
                           "  \"paused\": false,"
                           "  \"url\": \"%s\"}]",
-                          GetFilename("slow.txt.crdownload").c_str(),
                           download_url.c_str())));
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"filename\": {"
                           "    \"previous\": \"%s\","
                           "    \"current\": \"%s\"},"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id,
@@ skipping 17 matching lines @@
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
   if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
                           "  \"incognito\": true,"
                           "  \"mime\": \"text/plain\","
                           "  \"paused\": false,"
                           "  \"url\": \"%s\"}]",
-                          GetFilename("slow.txt.crdownload").c_str(),
                           download_url.c_str())));
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
       base::StringPrintf("[{\"id\":%d,"
                           "  \"filename\": {"
                           "    \"previous\": \"%s\","
                           "    \"current\": \"%s\"},"
                           "  \"state\": {"
                           "    \"current\": \"complete\","
                           "    \"previous\": \"in_progress\"}}]",
                           result_id,
@@ skipping 130 matching lines @@
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
   if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
                           "  \"incognito\": false,"
                           "  \"mime\": \"text/plain\","
                           "  \"paused\": false,"
                           "  \"url\": \"%s\"}]",
-                          GetFilename("slow.txt.crdownload").c_str(),
                           download_url.c_str())));
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"filename\": {"
                           "    \"previous\": \"%s\","
                           "    \"current\": \"%s\"},"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id,
@@ skipping 17 matching lines @@
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
   if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
                           "  \"incognito\": false,"
                           "  \"mime\": \"text/plain\","
                           "  \"paused\": false,"
                           "  \"url\": \"%s\"}]",
-                          GetFilename("data.txt.crdownload").c_str(),
                           download_url.c_str())));
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"filename\": {"
                           "    \"previous\": \"%s\","
                           "    \"current\": \"%s\"},"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id,
@@ skipping 20 matching lines @@
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
   if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
                           "  \"incognito\": false,"
                           "  \"mime\": \"text/html\","
                           "  \"paused\": false,"
                           "  \"url\": \"%s\"}]",
-                          GetFilename("file.txt.crdownload").c_str(),
                           download_url.c_str())));
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"filename\": {"
                           "    \"previous\": \"%s\","
                           "    \"current\": \"%s\"},"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id,
@@ skipping 181 matching lines @@
   int result_id = -1;
   ASSERT_TRUE(result->GetAsInteger(&result_id));
   DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
   if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"incognito\": false,"
-                          "  \"mime\": \"application/octet-stream\","
-                          "  \"paused\": false,"
-                          "  \"bytesReceived\": 164,"
-                          "  \"url\": \"%s\"}]", download_url.c_str())));
+                         "  \"incognito\": false,"
+                         "  \"mime\": \"application/octet-stream\","
+                         "  \"paused\": false,"
+                         "  \"url\": \"%s\"}]", download_url.c_str())));
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
-                          "  \"state\": {"
-                          "    \"previous\": \"in_progress\","
-                          "    \"current\": \"complete\"}}]", result_id)));
+                         "  \"state\": {"
+                         "    \"previous\": \"in_progress\","
+                         "    \"current\": \"complete\"},"
+                         "  \"filename\": {"
+                         "    \"previous\": \"%s\","
+                         "    \"current\": \"%s\"}}]",
+                         result_id,
+                         GetFilename("post-succeed.txt.crdownload").c_str(),
+                         GetFilename("post-succeed.txt").c_str())));
 }
 
 // Test that downloadPostSuccess would fail if the resource requires the POST
 // method, and chrome fails to propagate the |method| parameter back to the
 // server. This tests both that testserver.py does not succeed when it should
 // fail, and this tests how the downloads extension api exposes the failure to
 // extensions.
 IN_PROC_BROWSER_TEST_F(DownloadExtensionTest,
                        DownloadExtensionTest_Download_Post_Get) {
   LoadExtension("downloads_split");
@@ skipping 135 matching lines @@
   ASSERT_TRUE(result->GetAsInteger(&result_id));
 
   DownloadItem* item = GetCurrentManager()->GetActiveDownloadItem(result_id);
   if (!item) item = GetCurrentManager()->GetDownloadItem(result_id);
   ASSERT_TRUE(item);
   ScopedCancellingItem canceller(item);
   ASSERT_EQ(download_url, item->GetOriginalUrl().spec());
 
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadCreated,
       base::StringPrintf("[{\"danger\": \"safe\","
-                          "  \"filename\": \"%s\","
                           "  \"incognito\": false,"
                           "  \"mime\": \"text/plain\","
                           "  \"paused\": false,"
                           "  \"url\": \"%s\"}]",
-                          GetFilename("on_record.txt.crdownload").c_str(),
                           download_url.c_str())));
   ASSERT_TRUE(WaitFor(extension_event_names::kOnDownloadChanged,
       base::StringPrintf("[{\"id\": %d,"
                           "  \"filename\": {"
                           "    \"previous\": \"%s\","
                           "    \"current\": \"%s\"},"
                           "  \"state\": {"
                           "    \"previous\": \"in_progress\","
                           "    \"current\": \"complete\"}}]",
                           result_id,
                           GetFilename("on_record.txt.crdownload").c_str(),
                           GetFilename("on_record.txt").c_str())));
   std::string disk_data;
   EXPECT_TRUE(file_util::ReadFileToString(item->GetFullPath(), &disk_data));
   EXPECT_STREQ(kPayloadData, disk_data.c_str());
 }