chrome/test/data/nacl/extension_mime_handler/ppapi_extension_mime_handler.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string.h>
   6
   7 #include "native_client/src/include/nacl_macros.h"
   8 #include "native_client/src/shared/platform/nacl_check.h"
   9
  10 #include "ppapi/c/pp_bool.h"
  11 #include "ppapi/c/pp_errors.h"
  12 #include "ppapi/c/pp_input_event.h"
  13 #include "ppapi/c/ppb_instance.h"
  14 #include "ppapi/c/ppb_url_loader.h"
  15 #include "ppapi/c/ppp_instance.h"
  16
  17 #include "ppapi/native_client/tests/ppapi_test_lib/get_browser_interface.h"
  18 #include "ppapi/native_client/tests/ppapi_test_lib/test_interface.h"
  19
  20 namespace {
  21
  22
  23 // PostMessage is complicated in this test.  We're setting up an iframe with
  24 // src=foo where foo is handled by an extension as a content handler.  Webkit
  25 // generates the html page with the plugin embed, so we have no way to place
  26 // an event handler on the plugin or body of that page that's guaranteed to
  27 // execute before the plugin initializes.  Instead, we're just caching the
  28 // first error (if any) we encounter during load and responding to a normal
  29 // test message to return the results.
  30 const int kDocLoadErrorNone = 0;
  31 const int kDocLoadErrorInit = -1;
  32 int error_in_doc_load_line = kDocLoadErrorInit;
  33
  34 #define EXPECT_ON_LOAD(condition) \
  35   do { \
  36     if (!(condition)) { \
  37       if (kDocLoadErrorInit == error_in_doc_load_line) { \
  38         error_in_doc_load_line = __LINE__; \
  39       } \
  40     } \
  41   } while (0);
  42
  43 #define ON_LOAD_PASSED \
  44   do { \
  45     if (kDocLoadErrorInit == error_in_doc_load_line) \
  46       error_in_doc_load_line = kDocLoadErrorNone; \
  47   } while (0);
  48
  49 // Simple 1K buffer to hold the document passed through HandleDocumentLoad.
  50 const uint32_t kMaxFileSize = 1024;
  51 char buffer[kMaxFileSize];
  52 uint32_t buffer_pos = 0;
  53
  54 const char kKnownFileContents[] =
  55     "This is just a test file so we can verify HandleDocumentLoad.";
  56
  57 void ReadCallback(void* user_data, int32_t pp_error_or_bytes) {
  58   PP_Resource url_loader = reinterpret_cast<PP_Resource>(user_data);
  59
  60   EXPECT_ON_LOAD(pp_error_or_bytes >= PP_OK);
  61   if (pp_error_or_bytes < PP_OK) {
  62     PPBCore()->ReleaseResource(url_loader);
  63     return;
  64   }
  65
  66   if (PP_OK == pp_error_or_bytes) {
  67     // Check the contents of the file against the known contents.
  68     int diff = strncmp(buffer,
  69                       kKnownFileContents,
  70                       strlen(kKnownFileContents));
  71     EXPECT_ON_LOAD(diff == 0);
  72     PPBURLLoader()->Close(url_loader);
  73     PPBCore()->ReleaseResource(url_loader);
  74     ON_LOAD_PASSED;
  75   } else {
  76     buffer_pos += pp_error_or_bytes;
  77     PP_CompletionCallback callback =
  78         PP_MakeCompletionCallback(ReadCallback, user_data);
  79     pp_error_or_bytes =
  80         PPBURLLoader()->ReadResponseBody(url_loader,
  81                                          buffer + buffer_pos,
  82                                          kMaxFileSize - buffer_pos,
  83                                          callback);
  84     EXPECT(pp_error_or_bytes == PP_OK_COMPLETIONPENDING);
  85   }
  86 }
  87
  88 PP_Bool HandleDocumentLoad(PP_Instance instance,
  89                            PP_Resource url_loader) {
  90   // The browser will release url_loader after this method returns. We need to
  91   // keep it around until we have read all bytes or get an error.
  92   PPBCore()->AddRefResource(url_loader);
  93   void* user_data = reinterpret_cast<void*>(url_loader);
  94   PP_CompletionCallback callback =
  95       PP_MakeCompletionCallback(ReadCallback, user_data);
  96   int32_t pp_error_or_bytes = PPBURLLoader()->ReadResponseBody(url_loader,
  97                                                                buffer,
  98                                                                kMaxFileSize,
  99                                                                callback);
 100   EXPECT(pp_error_or_bytes == PP_OK_COMPLETIONPENDING);
 101   return PP_TRUE;
 102 }
 103
 104 const PPP_Instance ppp_instance_interface = {
 105   DidCreateDefault,
 106   DidDestroyDefault,
 107   DidChangeViewDefault,
 108   DidChangeFocusDefault,
 109   HandleDocumentLoad
 110 };
 111
 112 // This tests PPP_Instance::HandleDocumentLoad.
 113 void TestHandleDocumentLoad() {
 114   if (error_in_doc_load_line != kDocLoadErrorNone) {
 115     char error[1024];
 116     snprintf(error, sizeof(error),
 117         "ERROR at %s:%d: Document Load Failed\n",
 118         __FILE__, error_in_doc_load_line);
 119     fprintf(stderr, "%s", error);
 120     PostTestMessage(__FUNCTION__, error);
 121   }
 122   TEST_PASSED;
 123 }
 124
 125 // This tests PPB_Instance::IsFullFrame when the plugin is full frame.
 126 // Other conditions for IsFullFrame are tested by ppb_instance tests.
 127 void TestIsFullFrame() {
 128   PP_Bool full_frame = PPBInstance()->IsFullFrame(pp_instance());
 129   EXPECT(full_frame == PP_TRUE);
 130   TEST_PASSED;
 131 }
 132
 133
 134 }  // namespace
 135
 136
 137 void SetupTests() {
 138   RegisterTest("TestHandleDocumentLoad", TestHandleDocumentLoad);
 139   RegisterTest("TestIsFullFrame", TestIsFullFrame);
 140 }
 141
 142 void SetupPluginInterfaces() {
 143   RegisterPluginInterface(PPP_INSTANCE_INTERFACE, &ppp_instance_interface);
 144 }