Changed all @code to <code> and @endcode to </code> as per dmichael

ppapi/cpp/completion_callback.h

 // 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.
 
 #ifndef PPAPI_CPP_COMPLETION_CALLBACK_H_
 #define PPAPI_CPP_COMPLETION_CALLBACK_H_
 
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/logging.h"
@@ skipping 95 matching lines @@
   /// @return An int32_t containing a bit field combination of
   /// <code>PP_CompletionCallback_Flag</code> flags.
   int32_t flags() const { return cc_.flags; }
 
   /// MayForce() is used when implementing functions taking callbacks.
   /// If the callback is required and <code>result</code> indicates that it has
   /// not been scheduled, it will be forced on the main thread.
   ///
   /// <strong>Example:</strong>
   ///
-  /// @code
+  /// <code>
   ///
   /// int32_t OpenURL(pp::URLLoader* loader,
   ///                 pp::URLRequestInfo* url_request_info,
   ///                 const CompletionCallback& cc) {
   ///   if (loader == NULL || url_request_info == NULL)
   ///     return cc.MayForce(PP_ERROR_BADRESOURCE);
   ///   return loader->Open(*loader, *url_request_info, cc);
   /// }
   ///
-  /// @endcode
+  /// </code>
   ///
   /// @param[in] result PP_OK_COMPLETIONPENDING or the result of the completed
   /// operation to be passed to the callback function. PP_OK_COMPLETIONPENDING
   /// indicates that the callback has already been scheduled. Other
   /// non-positive values correspond to error codes from
   /// <code>pp_errors.h</code>. Positive values indicate additional information
   /// such as bytes read.
   ///
   /// @return <code>PP_OK_COMPLETIONPENDING</code> if the callback has been
   /// forced, result parameter otherwise.
@@ skipping 28 matching lines @@
 /// thread safe, but you can make it more thread-friendly by passing a
 /// thread-safe refcounting class as the second template element. However, it
 /// only guarantees safety for creating a callback from another thread, the
 /// callback itself needs to execute on the same thread as the thread that
 /// creates/destroys the factory. With this restriction, it is safe to create
 /// the <code>CompletionCallbackFactory</code> on the main thread, create
 /// callbacks from any thread and pass them to CallOnMainThread().
 ///
 /// <strong>Example: </strong>
 ///
-/// @code
+/// <code>
 ///
 ///   class MyHandler {
 ///    public:
 ///     MyHandler() : factory_(this), offset_(0) {
 ///     }
 ///
 ///    void ProcessFile(const FileRef& file) {
 ///       CompletionCallback cc = factory_.NewRequiredCallback(
 ///           &MyHandler::DidOpen);
 ///       int32_t rv = fio_.Open(file, PP_FileOpenFlag_Read, cc);
@@ skipping 38 matching lines @@
 ///     void ProcessBytes(const char* bytes, int32_t length) {
 ///       // Do work ...
 ///     }
 ///
 ///     pp::CompletionCallbackFactory<MyHandler> factory_;
 ///     pp::FileIO fio_;
 ///     char buf_[4096];
 ///     int64_t offset_;
 ///   };
 ///
-/// @endcode
+/// </code>
 ///
 template <typename T, typename RefCount = NonThreadSafeRefCount>
 class CompletionCallbackFactory {
  public:
 
   /// This constructor creates a <code>CompletionCallbackFactory</code>
   /// bound to an object. If the constructor is called without an argument,
   /// the default value of <code>NULL</code> is used. The user then must call
   /// Initialize() to initialize the object.
   ///
@@ skipping 345 matching lines @@
   CompletionCallbackFactory(const CompletionCallbackFactory&);
   CompletionCallbackFactory& operator=(const CompletionCallbackFactory&);
 
   T* object_;
   BackPointer* back_pointer_;
 };
 
 }  // namespace pp
 
 #endif  // PPAPI_CPP_COMPLETION_CALLBACK_H_