Move URLLoader, URLRequestInfo, and URLResponseInfo out of the dev directory...

ppapi/example/example.cc

 // Copyright (c) 2010 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 <math.h>
 #include <stdio.h>  // FIXME(brettw) erase me.
 #ifndef _WIN32
 #include <sys/time.h>
 #endif
 #include <time.h>
 
 #include <algorithm>
 
 #include "ppapi/c/dev/ppp_printing_dev.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_input_event.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/scriptable_object_deprecated.h"
-#include "ppapi/cpp/dev/url_loader_dev.h"
-#include "ppapi/cpp/dev/url_request_info_dev.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/rect.h"
+#include "ppapi/cpp/url_loader.h"
+#include "ppapi/cpp/url_request_info.h"
 #include "ppapi/cpp/var.h"
 
 static const int kStepsPerCircle = 800;
 
 void FlushCallback(void* data, int32_t result);
 
 void FillRect(pp::ImageData* image, int left, int top, int width, int height,
               uint32_t color) {
   for (int y = std::max(0, top);
        y < std::min(image->size().height() - 1, top + height);
@@ skipping 44 matching lines @@
 
 class MyFetcher {
  public:
   MyFetcher() : client_(NULL) {
     callback_factory_.Initialize(this);
   }
 
   void Start(const pp::Instance& instance,
              const pp::Var& url,
              MyFetcherClient* client) {
-    pp::URLRequestInfo_Dev request;
+    pp::URLRequestInfo request;
     request.SetURL(url);
     request.SetMethod("GET");
 
-    loader_ = pp::URLLoader_Dev(instance);
+    loader_ = pp::URLLoader(instance);
     client_ = client;
 
     pp::CompletionCallback callback =
         callback_factory_.NewCallback(&MyFetcher::DidOpen);
     int rv = loader_.Open(request, callback);
     if (rv != PP_ERROR_WOULDBLOCK)
       callback.Run(rv);
   }
 
-  void StartWithOpenedLoader(const pp::URLLoader_Dev& loader,
+  void StartWithOpenedLoader(const pp::URLLoader& loader,
                              MyFetcherClient* client) {
     loader_ = loader;
     client_ = client;
 
     ReadMore();
   }
 
  private:
   void ReadMore() {
     pp::CompletionCallback callback =
@@ skipping 19 matching lines @@
       DidFinish(result);
     }
   }
 
   void DidFinish(int32_t result) {
     if (client_)
       client_->DidFetch(result == PP_OK, data_);
   }
 
   pp::CompletionCallbackFactory<MyFetcher> callback_factory_;
-  pp::URLLoader_Dev loader_;
+  pp::URLLoader loader_;
   MyFetcherClient* client_;
   char buf_[4096];
   std::string data_;
 };
 
 class MyInstance : public pp::Instance, public MyFetcherClient {
  public:
   MyInstance(PP_Instance instance)
       : pp::Instance(instance),
         time_at_last_check_(0.0),
         fetcher_(NULL),
         width_(0),
         height_(0),
         animation_counter_(0),
         print_settings_valid_(false) {}
 
   virtual ~MyInstance() {
     if (fetcher_) {
       delete fetcher_;
       fetcher_ = NULL;
     }
   }
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
   }
 
-  virtual bool HandleDocumentLoad(const pp::URLLoader_Dev& loader) {
+  virtual bool HandleDocumentLoad(const pp::URLLoader& loader) {
     fetcher_ = new MyFetcher();
     fetcher_->StartWithOpenedLoader(loader, this);
     return true;
   }
 
   virtual bool HandleInputEvent(const PP_InputEvent& event) {
     switch (event.type) {
       case PP_INPUTEVENT_TYPE_MOUSEDOWN:
         //SayHello();
         return true;
@@ skipping 233 matching lines @@
 };
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp