Moving notification types which are chrome specific to a new header file chrome_notification_type...

chrome/test/plugin/pdf_browsertest.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 "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/window_sizer.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/content_notification_types.h"
 #include "content/common/notification_observer.h"
-#include "content/common/notification_type.h"
 #include "net/test/test_server.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace {
 
 // Include things like browser frame and scrollbar and make sure we're bigger
 // than the test pdf document.
 static const int kBrowserWidth = 1000;
 static const int kBrowserHeight = 600;
@@ skipping 43 matching lines @@
         FilePath(FILE_PATH_LITERAL("pdf_browsertest.pdf"))));
     ui_test_utils::NavigateToURL(browser(), url);
   }
 
   void VerifySnapshot(const std::string& expected_filename) {
     snapshot_different_ = true;
     expected_filename_ = expected_filename;
     TabContentsWrapper* wrapper =  browser()->GetSelectedTabContentsWrapper();
     wrapper->CaptureSnapshot();
     ui_test_utils::RegisterAndWait(this,
-                                   NotificationType::TAB_SNAPSHOT_TAKEN,
+                                   chrome::TAB_SNAPSHOT_TAKEN,
                                    Source<TabContentsWrapper>(wrapper));
     ASSERT_FALSE(snapshot_different_) << "Rendering didn't match, see result "
         "at " << snapshot_filename_.value().c_str();
   }
 
   void WaitForResponse() {
     // Even if the plugin has loaded the data or scrolled, because of how
     // pepper painting works, we might not have the data.  One way to force this
     // to be flushed is to do a find operation, since on this two-page test
     // document, it'll wait for us to flush the renderer message loop twice and
     // also the browser's once, at which point we're guaranteed to have updated
     // the backingstore.  Hacky, but it works.
     // Note that we need to change the text each time, because if we don't the
     // renderer code will think the second message is to go to next result, but
     // there are none so the plugin will assert.
 
     string16 query = UTF8ToUTF16(
         std::string("xyzxyz" + base::IntToString(next_dummy_search_value_++)));
     ASSERT_EQ(0, ui_test_utils::FindInPage(
         browser()->GetSelectedTabContentsWrapper(), query, true, false, NULL));
   }
 
  private:
   // NotificationObserver
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
-    if (type == NotificationType::TAB_SNAPSHOT_TAKEN) {
+    if (type == chrome::TAB_SNAPSHOT_TAKEN) {
       MessageLoopForUI::current()->Quit();
       FilePath reference = ui_test_utils::GetTestFilePath(
           GetPDFTestDir(),
           FilePath().AppendASCII(expected_filename_));
       base::PlatformFileInfo info;
       ASSERT_TRUE(file_util::GetFileInfo(reference, &info));
       int size = static_cast<size_t>(info.size);
       scoped_array<char> data(new char[size]);
       ASSERT_EQ(size, file_util::ReadFile(reference, data.get(), size));
 
@@ skipping 42 matching lines @@
       }
 
       if (snapshot_different_) {
         std::vector<unsigned char> png_data;
         gfx::PNGCodec::EncodeBGRASkBitmap(*bitmap, false, &png_data);
         if (file_util::CreateTemporaryFile(&snapshot_filename_)) {
           file_util::WriteFile(snapshot_filename_,
               reinterpret_cast<char*>(&png_data[0]), png_data.size());
         }
       }
-    } else if (type == NotificationType::LOAD_STOP) {
+    } else if (type == chrome::LOAD_STOP) {
       load_stop_notification_count_++;
     }
   }
 
   // True if the snapshot differed from the expected value.
   bool snapshot_different_;
   // Internal variable used to synchronize to the renderer.
   int next_dummy_search_value_;
   // The filename of the bitmap to compare the snapshot to.
   std::string expected_filename_;
   // If the snapshot is different, holds the location where it's saved.
   FilePath snapshot_filename_;
-  // How many times we've seen NotificationType::LOAD_STOP.
+  // How many times we've seen chrome::LOAD_STOP.
   int load_stop_notification_count_;
 
   scoped_ptr<net::TestServer> pdf_test_server_;
 };
 
 #if defined(OS_CHROMEOS)
 // TODO(sanjeevr): http://crbug.com/79837
 #define MAYBE_Basic DISABLED_Basic
 #else
 #define MAYBE_Basic Basic
@@ skipping 70 matching lines @@
 // This also loads all documents that used to crash, to ensure we don't have
 // regressions.
 // Flaky as per http://crbug.com/74548.
 IN_PROC_BROWSER_TEST_F(PDFBrowserTest, FLAKY_SLOW_Loading) {
   ASSERT_TRUE(pdf_test_server()->Start());
 
   NavigationController* controller =
       &(browser()->GetSelectedTabContents()->controller());
   NotificationRegistrar registrar;
   registrar.Add(this,
-                NotificationType::LOAD_STOP,
+                chrome::LOAD_STOP,
                 Source<NavigationController>(controller));
   std::string base_url = std::string("files/");
 
   file_util::FileEnumerator file_enumerator(
       ui_test_utils::GetTestFilePath(GetPDFTestDir(), FilePath()),
       false,
       file_util::FileEnumerator::FILES,
       FILE_PATH_LITERAL("*.pdf"));
   for (FilePath file_path = file_enumerator.Next();
        !file_path.empty();
        file_path = file_enumerator.Next()) {
     std::string filename = file_path.BaseName().MaybeAsASCII();
     ASSERT_FALSE(filename.empty());
 
 #if defined(OS_POSIX)
     if (filename == "sample.pdf")
       continue;  // Crashes on Mac and Linux.  http://crbug.com/63549
 #endif
 
     LOG(WARNING) << "PDFBrowserTest.Loading: " << filename;
 
     GURL url = pdf_test_server()->GetURL(base_url + filename);
     ui_test_utils::NavigateToURL(browser(), url);
 
     while (true) {
       int last_count = load_stop_notification_count();
-      // We might get extraneous NotificationType::LOAD_STOP notifications when
+      // We might get extraneous chrome::LOAD_STOP notifications when
       // doing async loading.  This happens when the first loader is cancelled
       // and before creating a byte-range request loader.
       bool complete = false;
       ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
           browser()->GetSelectedTabContents()->render_view_host(),
           std::wstring(),
           L"window.domAutomationController.send(plugin.documentLoadComplete())",
           &complete));
       if (complete)
         break;
@@ skipping 22 matching lines @@
   ASSERT_TRUE(ui_test_utils::ExecuteJavaScript(
       browser()->GetSelectedTabContents()->render_view_host(),
       std::wstring(),
       L"reloadPDF();"));
 
   ASSERT_TRUE(ui_test_utils::WaitForNavigationInCurrentTab(browser()));
   ASSERT_EQ("success", browser()->GetSelectedTabContents()->GetURL().query());
 }
 
 }  // namespace